/*
============================================================================
    * Name : CEngine.cpp
    * Part of : Example3D
    * Description : Definition of CEngine
    * Copyright (c) 2007 Nokia Corporation
============================================================================
    */

// INCLUDES
#include "CEngine.h"
#include "CGameTimer.h"
#include "CGame.h"
#include "CPictureLoader.h"
#include <eikenv.h>
#include <eikappui.h>
#include <f32file.h>

// CONSTANTS
const TInt KUpdateInterval = 1000000 / 64;  // 64 times per second "Move" update
const TInt KMaxNumUpdates = 10;

// MEMBER FUNCTIONS
CEngine* CEngine::NewL( CWindowGc& aGc, RWindow& aWindow, 
                        TDisplayMode aDisplayMode )
    {
    CEngine* self = new( ELeave )CEngine( aGc, aWindow, aDisplayMode );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

CEngine::~CEngine()
    {
    delete iFbsBitmapBuffer;
    delete iTimer;
    delete iGame;
    delete iFbsScreenDevice;
    delete iBitmapUtil;

    eglMakeCurrent( iGldisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
    eglDestroyContext( iGldisplay, iGlcontext );
    eglDestroySurface( iGldisplay, iGlsurface );
    eglTerminate( iGldisplay );
    }

void CEngine::ConstructL()
    {
    iPaused = ETrue;

    // Define properties for the preferred EGLSurface, try to match with window depth
    EGLint attribList[ ] = { EGL_BUFFER_SIZE, 0,
    EGL_DEPTH_SIZE, 15,
    EGL_NONE };

    switch( iWindow.DisplayMode() )
        {
        case( EColor4K ) : { attribList[1] = 12; break; }
        case( EColor64K ): { attribList[1] = 16; break; }
        case( EColor16M ): { attribList[1] = 24; break; }
        default: attribList[1] = 32; // for EColor16MU
        }   
    
    EGLint numConfigs;
    EGLint majorVersion;
    EGLint minorVersion;
     
    iGldisplay = eglGetDisplay( EGL_DEFAULT_DISPLAY );
    if( iGldisplay == EGL_NO_DISPLAY )
        {
        User::Panic( _L("GL No Display"),0 );
        }
    if( !eglInitialize( iGldisplay, &majorVersion, &minorVersion ) ) 
        {
        User::Panic( _L("GL Init"), 0 );
        }
    if( !eglChooseConfig( iGldisplay, attribList, &iGlconfig, 1, &numConfigs ) )
        {
        User::Panic(_L("GL Config"), 0 );
        }
    iGlcontext = eglCreateContext( iGldisplay, iGlconfig, NULL, NULL );
    if( iGlcontext==0 )
        {
        User::Panic( _L("GL Context"), 0 );
        }
    iGlsurface = eglCreateWindowSurface( iGldisplay, iGlconfig, &iWindow, NULL );
    if( iGlsurface==0 )
        {
        User::Panic( _L("GL Surface"), 0 );
        }
    
    eglMakeCurrent( iGldisplay, iGlsurface, iGlsurface, iGlcontext );

    iGame = CGame::NewL( iDisplayMode );
    iTimer = CGameTimer::NewL( *this );
    iTime.HomeTime();

    // Some devices have difficulties to multitask with
    // this application using idle time.
    // This should help it a little
    //RProcess().SetPriority( EPriorityLow );
    }

void CEngine::InitScreen( const TRect& aRect )
    {
    iDrawRect = aRect;
    iBuffer.iSize = iDrawRect.Size();
    iBuffer.iMode = iDisplayMode;
    }

CEngine::CEngine( CWindowGc& aGc, RWindow& aWindow, 
                  TDisplayMode aDisplayMode )
    : iGc( aGc ), iWindow( aWindow ), iDisplayMode( aDisplayMode )
    {
    }

TInt CEngine::DoGameFrameL()
    {
    if( iPaused )
        {
        // stop gametimer
        return EFalse;
        }

    TPoint pos = iWindow.Position();
    TSize size = iWindow.Size();
    if( size != iDrawRect.Size() || pos != iDrawRect.iTl )
        {
        TRect rect( pos, size );
        InitScreen( rect );
        return ETrue;
        }
    
    // Calculate number of updates that should happen since last game frame
    TTime time;
    time.HomeTime();
    TInt updates = I64LOW(time.MicroSecondsFrom( iTime ).Int64());
    iUpdates += updates;
    updates = iUpdates / KUpdateInterval;
    
    iTime = time.Int64();
    
    TInt i;
    for( i=0; i<updates; i++ )
        {
        iGame->Move( iKey );
        }
    iUpdates -= updates * KUpdateInterval;
    
    // Draw with OpenGL
    // GL double buffer swap
    eglSwapBuffers( iGldisplay, iGlsurface);
    iGame->Draw( iBuffer );
    RRegion drawRegion;
    drawRegion.AddRect( iDrawRect );
    drawRegion.Clear();
            
    // continue gametimer
    return ETrue;
    }

void CEngine::KeyEvent( const TKeyEvent& aKeyEvent,TEventCode aType )
    {
    switch( aType )
        {
        case EEventKeyDown:
            {
            iKey[ aKeyEvent.iScanCode ] = 1;
            break;
            }
        case EEventKeyUp:
            {
            iKey[ aKeyEvent.iScanCode ] = 0;
            break;
            }
        default:
            {
            break;
            }
        }
    }

void CEngine::Start()
    {
    if( !iPaused ) return;
    iPaused = EFalse;
    iTimer->Start();
    }

void CEngine::Stop()
    {
    if( iPaused )
        return;
    ResetKeys();
    iPaused = ETrue;
    iTimer->Cancel();
    }

void CEngine::ResetKeys()
    {
    for (TInt i = 0; i < 256; i++)
        {
        iKey[i] = 0;
        }
    }
    
void CEngine::Command( TInt aCommand )
    {
    if( iGame )
        {
        iGame->Command( aCommand );
        }
    }