// 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:

 //

 #include "model.h"

 #include "geometrystructs.h"

 #include "egldefs.h"

 #include "eglerror.h"

 #include <e32math.h>

 const TInt KMoonPositionCount = 100;

 const TInt KSunPositionCount = 100;

 const TInt KSunOrbitRadius = 2000; //heliocentric

 const TInt KMoonOrbitRadius = 100;

 const TInt KModelDistanceFromCamera = 200;

 const TInt KMinResolution = 5;

 const TInt KMaxResolution = 50;

 const TInt KDefaultResolution = 50;

 const TInt KSunRadius=100;

 const TInt KPlanetRadius=50;

 const TInt KMoonRadius = 10;

 _LIT(KRed, "red");

 _LIT(KGreen, "green");

 _LIT(KBlue, "blue");

 _LIT(KBlack, "black");

 CModel* CModel::NewL(EGLDisplay aDisplay, EGLSurface aSurface)

     {

     TPtrC defaultColor(KBlack);

     return NewL(aDisplay, aSurface, defaultColor);

     }

 CModel* CModel::NewL(EGLDisplay aDisplay, EGLSurface aSurface, TPtrC aBackgroundColor)

     {

     CModel* self = new(ELeave) CModel(aDisplay, aSurface);

     CleanupStack::PushL(self);

     self->ConstructL(aBackgroundColor);

     CleanupStack::Pop(self);

     return self;

     }

 void CModel::PrecalculateOrbitL(TInt aOrbitingDistance, RArray<Vertex3F>& aVertices, TInt aPositionCount, TReal aAngle)

     {

     //fghCircleTable allocates for sin and cos tables, 

     //so we must not fail to append vertices to the array,

     //so we must reserve all the space we need.

     aVertices.ReserveL(aPositionCount);

     //precalculate the positions of the sun

     TReal32 *sint1,*cost1;

     User::LeaveIfError(fghCircleTable(&sint1,&cost1, aPositionCount));

     TReal radians = aAngle*(KPi/180);

     TReal32 cosA = cos(radians);

     TReal32 sinA = sin(radians);

     TReal32 x,y = 0;

     TReal32 cosCalc = aOrbitingDistance * cosA;

     TReal32 sinCalc = aOrbitingDistance * sinA;

     for(TInt i = 0; i < aPositionCount;  i++)

         {

         x = cost1[i] * cosCalc;

         y = cost1[i] * sinCalc;

         Vertex3F v(x,y, sint1[i]*aOrbitingDistance);

         User::LeaveIfError(aVertices.Append(v));

         }

     delete[] sint1;

     delete[] cost1;

     }

 void CModel::ConstructL(TPtrC aBackgroundColor)

     {

     iResolution=KDefaultResolution;

     CSolidSphere* newSun = CSolidSphere::NewLC(KSunRadius, iResolution, iResolution);

     CSolidSphere* newPlanet = CSolidSphere::NewLC(KPlanetRadius, iResolution, iResolution);

     CSolidSphere* newMoon = CSolidSphere::NewLC(KMoonRadius, iResolution, iResolution);

     SetShapes(newSun, newPlanet, newMoon);

     CleanupStack::Pop(3, newSun);

     PrecalculateOrbitL(KSunOrbitRadius, iSunPositions, KSunPositionCount, 135);

     PrecalculateOrbitL(KMoonOrbitRadius, iMoonPositions, KMoonPositionCount, 23.5);

     if(aBackgroundColor == KRed)

         {

         iBackgroundColor[ERed] = 0.5;

         }

     else if (aBackgroundColor == KGreen)

         {

         iBackgroundColor[EGreen] = 0.5;

         }

     else if (aBackgroundColor == KBlue)

         {

         iBackgroundColor[EBlue] = 0.5;

         }

     }

 CModel::CModel(EGLDisplay aDisplay, EGLSurface aSurface)

     :iDisplay(aDisplay), iSurface(aSurface)

     {

     }

 CModel::~CModel()

     {

     delete iSun;

     delete iPlanet;

     delete iMoon;

     iSunPositions.Close();

     iMoonPositions.Close();

     }

 void CModel::SetShapes(CSolidSphere* aSun, CSolidSphere* aPlanet, CSolidSphere* aMoon)

     {

     delete iSun;

     iSun = aSun;

     delete iPlanet;

     iPlanet = aPlanet;

     delete iMoon;

     iMoon = aMoon;

     }

 void CModel::DrawToBuffer(TInt aTime) const

     {

     InitialiseFrame();

     DrawModelData(aTime);

     }

 void CModel::InitialiseFrame() const

     {

     glEnable(GL_CULL_FACE);

     glEnable(GL_DEPTH_TEST); 

     glEnable(GL_COLOR_ARRAY);

     glEnable(GL_LIGHTING);

     glEnable(GL_LIGHT0);

     glEnableClientState(GL_VERTEX_ARRAY);

     glEnableClientState(GL_NORMAL_ARRAY);

     glClearColor(iBackgroundColor[ERed], iBackgroundColor[EGreen], iBackgroundColor[EBlue], iBackgroundColor[EAlpha]); 

     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

     glCullFace(GL_FRONT);   

     glShadeModel (GL_SMOOTH);

     // Set the projection parameters

     glMatrixMode(GL_PROJECTION);

     glLoadIdentity();

     EGLint height;

     if(!eglQuerySurface(iDisplay, iSurface, EGL_HEIGHT, &height))

         {

         ProcessEglError();

         }

     EGLint width;

         if(!eglQuerySurface(iDisplay, iSurface, EGL_WIDTH, &width))

             {

             ProcessEglError();

             }

     GLfloat widthf = width;

     GLfloat heightf = height;

     GLfloat aspectRatio = widthf/heightf;

     glFrustumf( -(aspectRatio*KFrustumHeight), (aspectRatio*KFrustumHeight), 

                 -KFrustumHeight, KFrustumHeight, 

                 KFrustumNear, KFrustumFar);

     }

 void CModel::DrawModelData(TInt aTime) const

     {

     //draw a light source where the sun is

     glMatrixMode(GL_MODELVIEW);

     glLoadIdentity();

     GLfloat sun_color[] = { 1.0, 1.0, 0.5333, 1 };

     Vertex3F vSun = iSunPositions[aTime%KSunPositionCount];

     vSun.iZ-=KModelDistanceFromCamera;

     GLfloat light0position[] = {vSun.iX, vSun.iY, vSun.iZ, 1.0 };

     glLightfv(GL_LIGHT0, GL_POSITION, light0position);

     glLightfv(GL_LIGHT0, GL_SPECULAR, sun_color);  

     //draw the sun

     glMatrixMode(GL_MODELVIEW);

     glLoadIdentity();

     //this is obviously wrong: I don't understand why the z-coord for the 

     //sun needs to be the negation of the z-coord for the light source position,

     //in order for the light to appear to come from the sun!

     glTranslatef(vSun.iX, vSun.iY, -vSun.iZ);

     glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, sun_color);

     iSun->Draw();

     //draw the planet

     glMatrixMode(GL_MODELVIEW);

     glLoadIdentity();

     glTranslatef(0, 0, -KModelDistanceFromCamera);

     GLfloat mat_planet_color[] = { 0.459, 0.679, 0.8, 1 };

     GLfloat mat_planet_shininess[] = { 30.0 };

     GLfloat mat_no_emission[] = {0, 0, 0, 0};

     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_planet_color);

     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_planet_color);

     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_planet_color);

     glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_planet_shininess);

     glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, mat_no_emission);

     iPlanet->Draw();

     //draw the moon

     glMatrixMode(GL_MODELVIEW);

     glLoadIdentity();

     Vertex3F vMoon = iMoonPositions[aTime%KMoonPositionCount];

     vMoon.iZ-=KModelDistanceFromCamera;

     glTranslatef(vMoon.iX, vMoon.iY, vMoon.iZ);

     GLfloat mat_moon_specular[] = { 0.5, 0.5, 0.5, 1.0 };

     GLfloat mat_moon_shininess[] = { 500.0 };

     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_moon_specular);

     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_moon_specular);

     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_moon_specular);

     glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_moon_shininess);  

     glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, mat_no_emission);

     iMoon->Draw();

     }

 void CModel::SetResolutionL(TInt aResolution)

     {

     aResolution *= 5;

     if(aResolution > KMaxResolution)

         {

         aResolution = KMaxResolution;

         }

     if(aResolution < KMinResolution)

         {

         aResolution = KMinResolution;

         }

     iResolution = aResolution;

     CSolidSphere* newSun = CSolidSphere::NewLC(KSunRadius, iResolution, iResolution);

     CSolidSphere* newPlanet = CSolidSphere::NewLC(KPlanetRadius, iResolution, iResolution);

     CSolidSphere* newMoon = CSolidSphere::NewLC(KMoonRadius, iResolution, iResolution);

     SetShapes(newSun, newPlanet, newMoon);  

     CleanupStack::Pop(3, newSun);

     }