// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/*

 * Portions of this code, in particular the fghCircleTable function and the code to 

 * calculate the vertices for the solid sphere, is ported from freeglut_geometry.cpp 

 * which is distributed under the following terms:

 * 

 ****************************************************************** 

 * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.

 * Written by Pawel W. Olszta, <olszta@sourceforge.net>

 * Creation date: Fri Dec 3 1999

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *********************************************************************

 * Apart from porting to use Open GL ES instead of Open GL the other major change is 

 * to separate out the code that calculates vertices from the code that draws the shape.   

 */

#include "geometrystructs.h"

#include <GLES/gl.h>

#include <e32math.h>

float sin(float x)

	{

	double t = x;

	double r;

	TInt error = Math::Sin(r,t);

	ASSERT(error==KErrNone);

	return r;

	}

float cos(float x)

	{

	double t = x;

	double r;

	TInt error = Math::Cos(r,t);

	ASSERT(error==KErrNone);

	return r;

	}

int abs(int x)

	{

	return Abs(x);

	}

Vertex3F::Vertex3F(float x, float y, float z)

	:iX(x), iY(y), iZ(z)

	{

	}

Vertex3F::Vertex3F()

:iX(0), iY(0), iZ(0)

	{

	}

int fghCircleTable(float **sint,float **cost,const int n)

{

    int i;

    /* Table size, the sign of n flips the circle direction */

    const int size = abs(n);

    /* Determine the angle between samples */

    const float angle = 2*KPi/(float)( ( n == 0 ) ? 1 : n );

    /* Allocate memory for n samples, plus duplicate of first entry at the end */

    *sint = new float[sizeof(float) * size+1];

    if(*sint==NULL)

		{

		return KErrNoMemory;

		}

    *cost = new float[sizeof(float) * size+1];

    if(*cost==NULL)

		{

		delete[] sint;

		return KErrNoMemory;

		}

    /* Compute cos and sin around the circle */

    (*sint)[0] = 0.0;

    (*cost)[0] = 1.0;

    for (i=1; i<size; i++)

    {

    (*sint)[i] = sin(angle*i);

    (*cost)[i] = cos(angle*i);

    }

    /* Last sample is duplicate of the first */

    (*sint)[size] = (*sint)[0];

    (*cost)[size] = (*cost)[0];

    return KErrNone;

}

CSolidSphere* CSolidSphere::NewLC(TReal aRadius, TInt aSlices, TInt aStacks)

	{

	CSolidSphere* self = new(ELeave) CSolidSphere(aSlices, aStacks);

	CleanupStack::PushL(self);

	self->ConstructL(aRadius);

	return self;

	}

CSolidSphere::~CSolidSphere()

	{

	delete[] iTopVertices;

	delete[] iTopNormals;

	delete[] iBottomVertices;

	delete[] iBottomNormals;

	delete[] iStackVertices;

	delete[] iStackNormals;

	}

void CSolidSphere::Draw() const

	{

//top fan

	glVertexPointer(3, GL_FLOAT, 0, iTopVertices);

	glNormalPointer(GL_FLOAT, 0, iTopNormals);

	glDrawArrays(GL_TRIANGLE_FAN, 0, iSlices+2);

//stacks, one at a time	

	glVertexPointer(3, GL_FLOAT, 0, iStackVertices);

	glNormalPointer(GL_FLOAT, 0, iStackNormals);

	TInt offset = 0;

	TInt verticesPerStack = (iSlices+1)*2;

	for(TInt i=1; i<iStacks-1; i++ )

		{

		glDrawArrays(GL_TRIANGLE_STRIP, offset, verticesPerStack);

		offset+=verticesPerStack;

		}

//bottom fan

	glVertexPointer(3, GL_FLOAT, 0, iBottomVertices);

	glNormalPointer(GL_FLOAT, 0, iBottomNormals);

	glDrawArrays(GL_TRIANGLE_FAN, 0, iSlices+2);

	}

CSolidSphere::CSolidSphere(TInt aSlices, TInt aStacks)

	:iSlices(aSlices), iStacks(aStacks)

	{

	}

void CSolidSphere::ConstructL(TReal aRadius)

	{

	//* Pre-computed circle 

	float* sint1 = NULL;

	float* cost1 = NULL;

	float* sint2 = NULL;

	float* cost2 = NULL;

	fghCircleTable(&sint1,&cost1,-iSlices);

	CleanupArrayDeletePushL(sint1);

	CleanupArrayDeletePushL(cost1);

	fghCircleTable(&sint2,&cost2,iStacks*2);

	CleanupArrayDeletePushL(sint2);

	CleanupArrayDeletePushL(cost2);

	//* The top stack is covered with a triangle fan 

	int i,j;

	//* Adjust z and radius as stacks are drawn. 

	float z0,z1;

	float r0,r1;

	z0 = 1.0;

	z1 = cost2[(iStacks>0)?1:0];

	r0 = 0.0;

	r1 = sint2[(iStacks>0)?1:0];

	iTopVertices = new (ELeave) Vertex3F[iSlices+2];

	iTopNormals = new (ELeave) Vertex3F[iSlices+2];

	TInt topVerticesIndex = 0;

	iTopVertices[topVerticesIndex] = Vertex3F(0,0,aRadius);

	iTopNormals[topVerticesIndex] = Vertex3F(0,0,1);

	for(j=iSlices; j>=0; j--)

	  	{

	  	topVerticesIndex++;

	    Vertex3F vertex(cost1[j]*r1*aRadius, sint1[j]*r1*aRadius, z1*aRadius);

	    iTopVertices[topVerticesIndex] = vertex;

	    Vertex3F normal(cost1[j]*r1,        sint1[j]*r1,        z1       );

	    iTopNormals[topVerticesIndex] = normal;

	    }

	//*calculate the vertices for each stack

	TInt stackVertexCount = ((iSlices+1)*2) *iStacks; 

	iStackVertices = new (ELeave) Vertex3F[stackVertexCount];

	iStackNormals = new (ELeave) Vertex3F[stackVertexCount];	

	TInt stackIndex = 0;

	for( i=1; i<iStacks-1; i++ )

	    {

	    z0 = z1; z1 = cost2[i+1];

	    r0 = r1; r1 = sint2[i+1];

	    for(j=0; j<=iSlices; j++)

	       {

	       Vertex3F v1(cost1[j]*r1*aRadius, sint1[j]*r1*aRadius, z1*aRadius);

	       Vertex3F v2(cost1[j]*r0*aRadius, sint1[j]*r0*aRadius, z0*aRadius);

	       iStackVertices[stackIndex*2] = v1;

	       iStackVertices[(stackIndex*2)+1] = v2;	                 

		   Vertex3F n1(cost1[j]*r1,        sint1[j]*r1,        z1);

		   Vertex3F n2(cost1[j]*r0,        sint1[j]*r0,        z0);

		   iStackNormals[stackIndex*2] = n1;

		   iStackNormals[(stackIndex*2)+1] = n2;

		   stackIndex++;

		   }

	    }

	//* The bottom stack is covered with a triangle fan 

	z0 = z1;

	r0 = r1;

	iBottomVertices = new (ELeave) Vertex3F[iSlices+2];

	iBottomNormals = new (ELeave) Vertex3F[iSlices+2];

	iBottomVertices[0] = Vertex3F(0,0,-aRadius);

	iBottomNormals[0] = Vertex3F(0,0,-1);

    for(j=0; j<=iSlices; j++)

    	{

	    Vertex3F vertex(cost1[j]*r0*aRadius, sint1[j]*r0*aRadius, z0*aRadius);

	    iBottomVertices[j+1] = vertex;

	    Vertex3F normal(cost1[j]*r0, sint1[j]*r0, z0);

	    iBottomNormals[j+1] = normal;

	    }

    //* Release sin and cos tables 

    CleanupStack::PopAndDestroy(4);

	}