// 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);
    }