S60 3rd Edition SDK for Symbian OS Example Applications Guide

LensFlare.cpp

/*
* ==============================================================================
*  Name        : LensFlare.cpp
*  Part of     : OpenGLEx / LensFlare
*  Interface   : 
*  Description : 
*  Version     : 
*
*  Copyright (c) 2004-2006 Nokia Corporation.
*  This material, including documentation and any related 
*  computer programs, is protected by copyright controlled by 
*  Nokia Corporation.
* ==============================================================================
*/

// INCLUDE FILES
#include "lensflare.h"
#include <aknnotewrappers.h> 
#include <e32math.h>

#include "model.h" 

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS
#define scl 1.0

// LOCAL CONSTANTS AND MACROS

/* Lens flare configuration */
static const TFlareConfig LensFlareConfigs[] =
        {
    { 0, (GLfloat)(+1.2 / 01.0), (GLfloat)(0.15 / scl) },
    { 0, (GLfloat)(+1.0 / 01.0), (GLfloat)(1.00 / scl) },
    { 2, (GLfloat)(+1.0 / 01.5), (GLfloat)(0.50 / scl) },
    { 1, (GLfloat)(+1.0 / 01.6), (GLfloat)(0.25 / scl) },
    { 2, (GLfloat)(+1.0 / 02.0), (GLfloat)(0.50 / scl) },
    { 0, (GLfloat)(+1.0 / 02.3), (GLfloat)(0.25 / scl) },
    { 1, (GLfloat)(+1.0 / 17.0), (GLfloat)(0.35 / scl) },
    { 2, (GLfloat)(+1.0 / 09.0), (GLfloat)(0.20 / scl) },
    { 2, (GLfloat)(-1.0 / 02.0), (GLfloat)(0.50 / scl) },
    { 1, (GLfloat)(-1.0 / 04.0), (GLfloat)(0.25 / scl) },
    { 1, (GLfloat)(-1.0 / 05.0), (GLfloat)(0.45 / scl) }
        };

/* Length of LensFlareConfigs */
static const TUint8 LensFlareConfigCount = sizeof(LensFlareConfigs)/sizeof(LensFlareConfigs[0]);

/* Define vertice coordinates for the ground plane */
static const GLbyte planeVertices[4 * 3] =
        {
    +1,0,-1,
    +1,0,+1,
    -1,0,+1,
    -1,0,-1
        };

/* Define indices for drawing the triangles of the ground plane */
static const GLubyte planeTriangles[2 * 3] =
        {
    0,2,1,
    0,3,2
        };

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
// CLensflare::NewL
// Two-phased constructor. Can leave.
// -----------------------------------------------------------------------------
//
CLensflare* CLensflare::NewL( TUint aWidth, TUint aHeight )
        {
    /* Symbian 2-phase constructor. Calls both the default 
       C++ constructor and Symbian ConstructL methods */
    CLensflare* self = new (ELeave) CLensflare( aWidth, aHeight );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
        }

/**
 * Destructor. 
 */
CLensflare::~CLensflare()
        {
        }

// -----------------------------------------------------------------------------
// CLensflare::CLensflare
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CLensflare::CLensflare( TUint aWidth, TUint aHeight )
        : CFiniteStateMachine()
        {
    iScreenWidth  = aWidth;
    iScreenHeight = aHeight;

        }

// -----------------------------------------------------------------------------
// CLensflare::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CLensflare::ConstructL( void )
        {
        }

// -----------------------------------------------------------------------------
// CLensflare::AppInit
// Initializes the application.
// -----------------------------------------------------------------------------
//
void CLensflare::AppInitL( void )
        {
    /* Set the screen background color. */
    glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );

    /* Enable back face culling. */
    glEnable( GL_CULL_FACE  );
    glEnable( GL_TEXTURE_2D );
    glEnable( GL_DEPTH_TEST );

    /*Disable lighting */
    glDisable( GL_LIGHTING );

    /* In this example, speed is  more important than quality */
    glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST );

    /* Initialize viewport and projection. */
    glViewport( 0, 0, iScreenWidth, iScreenHeight );
    glMatrixMode( GL_PROJECTION );

    // Calculate the view frustrum
    GLfloat aspectRatio = (GLfloat)(iScreenWidth) / (GLfloat)(iScreenHeight);
    glFrustumf( FRUSTUM_LEFT * aspectRatio, FRUSTUM_RIGHT * aspectRatio,
                FRUSTUM_BOTTOM, FRUSTUM_TOP,
                FRUSTUM_NEAR, FRUSTUM_FAR );

    glMatrixMode( GL_MODELVIEW );

    /* Enable vertex arrays. */
    glEnableClientState( GL_VERTEX_ARRAY );
    /* Enable texture arrays. */
    glEnableClientState( GL_TEXTURE_COORD_ARRAY );

    glTexEnvx( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );

    iDistance = 250;
    iElevation = 8;
    iAzimuth = 90;
    iDirection = +1;

    iLookUpTable = CLookUpTable::NewL( CLookUpTable::ESin | CLookUpTable::ECos );

        // Construct a texture manager that uses the application's private
        // directory as the source location for all textures.
    iTextureManager = CTextureManager::NewL( iScreenWidth, iScreenWidth,
                                             FRUSTUM_TOP, FRUSTUM_BOTTOM, FRUSTUM_RIGHT, FRUSTUM_LEFT, FRUSTUM_NEAR,                                
                                             this );

    TBufC<MAX_TEXTURE_NAME> LensFlareTextureNames[4];

    //Set of textures that will be used by the lens flare effect.
    _LIT(KLens1, "lens1.jpg");
    _LIT(KLens2, "lens2.jpg");
    _LIT(KLens3, "lens3.jpg");
    LensFlareTextureNames[0] = KLens1;
    LensFlareTextureNames[1] = KLens2;
    LensFlareTextureNames[2] = KLens3;

    iLensFlareEffect = CLensFlareEffect::NewL(  LensFlareTextureNames, 3,
                                                LensFlareConfigs, LensFlareConfigCount, 
                                                iTextureManager,
                                                iScreenWidth, iScreenHeight);
    
    //Start to load the textures.
    iTextureManager->DoLoadL();
        }

// -----------------------------------------------------------------------------
// CLensflare::AppExit
// Release any allocations made in AppInit.
// -----------------------------------------------------------------------------
//
void CLensflare::AppExit( void )
        {
    delete iTextureManager;
    delete iLensFlareEffect;
    delete iLookUpTable;
        }


// -----------------------------------------------------------------------------
// CLensflare::DrawText
// Draw the 'NokiaGL' text.
// -----------------------------------------------------------------------------
//
void CLensflare::DrawText(TBool aReflection)
        {
    glDisable( GL_DEPTH_TEST );

    glLoadIdentity();

    T3DModel::MakeWorldViewMatrix( iCamera, TVector(0.0f, 0.0f, 0.0f));

    if ( aReflection )
        {
        glScalef( 1.0f , -1.0f, 1.0f);// reflect across Y=0 plane. 
        }
    /* Scale the model to fit the screen. */
    glScalef( 0.01f, 0.01f, 0.01f );

    glDisable( GL_TEXTURE_2D );
    glColor4f( 0, 0, 1.f, 1.0f ); // Blue (nokia's logo color)
    glVertexPointer( 3, GL_SHORT, 0, TextVertices );
    glDrawElements( GL_TRIANGLES, TextIndicesCount, GL_UNSIGNED_SHORT, TextIndices );
    glEnable( GL_TEXTURE_2D );

    glEnable( GL_DEPTH_TEST );
        }

// -----------------------------------------------------------------------------
// CLensflare::DrawPlane
// Draw the ground plane.
// -----------------------------------------------------------------------------
//
void CLensflare::DrawPlane()
        {
    glLoadIdentity();
    T3DModel::MakeWorldViewMatrix(iCamera, TVector(0.0f, 0.0f, 0.0f));
    glScalef( 250, 0, 250 );

    //Enable alpha blending in order to blend the reflected text with the groud plane.
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glColor4f( 0.7f, 0.0f, 0.0f, 0.70f ); // 70% of groud plane color - 30% of text color.

    glDisable( GL_TEXTURE_2D );
    glVertexPointer( 3, GL_BYTE, 0, planeVertices );
    glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, planeTriangles );
    glEnable( GL_TEXTURE_2D );

    glDisable(GL_BLEND);
        }

// -----------------------------------------------------------------------------
// CLensflare::AppCycle
// Draws and animates the objects.
// -----------------------------------------------------------------------------
//
void CLensflare::AppCycle( TInt /*aFrame*/ )
        {

    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    iT0 = iT1;
    do 
                {
        iT1 = GetTimeTick();
        //Compute the ellapsed time (in sec.) between the current and the previous frame.
        iElapsedTime = I64LOW( iT1.MicroSecondsFrom( iT0 ).Int64() * ( 1 / 1000000.0f ) );
                } while ( iElapsedTime == 0 );                   
    
        iFPSCount = 1 / (iElapsedTime);        //Compute the frame rate.

    /* Move the camera. */
    TurnCameraAzimuth(iDirection);

    GLfloat sinA, cosA, sinE, cosE;

    sinE = iLookUpTable->Sin((GLushort)iElevation);
    cosE = iLookUpTable->Cos((GLushort)iElevation);
    sinA = iLookUpTable->Sin((GLushort)iAzimuth);
    cosA = iLookUpTable->Cos((GLushort)iAzimuth);

    GLfloat x = iDistance * cosE * cosA;
    GLfloat y = iDistance * sinE;
    GLfloat z = iDistance * cosE * sinA;

    iCamera.LookAt(TVector(x, y, z ), TVector(0.0f, 0.0f, 0.0f ), TVector(0.0f, 1.0f, 0.0f));

    /*Draws the gound plane and the 'NokiaGL' text in the normal and the reflected form.*/
    DrawText(ETrue);
    DrawPlane();
    DrawText(EFalse);

    /* Animate and draw the lens flare. */
    iLensAngle += (20 * iDirection * iElapsedTime);
    if ( iLensAngle < 0 )
        {
        iLensAngle = 359;
        }
    else if ( iLensAngle > 359 ) 
        {
        iLensAngle = 0;
        }
    else
        {
        }
    
    GLfloat sin = iLookUpTable->Sin((GLushort)iLensAngle);
    GLfloat cos = iLookUpTable->Cos((GLushort)iLensAngle);

    iLensRadius = 65 * (sin > 0 ? sin : -sin);
    TReal xx = iLensRadius * cos + iScreenWidth / 2;
    TReal yy = iLensRadius * sin + iScreenHeight / 2;

    iLensFlareEffect->DrawAt((TInt)xx, (TInt)yy);
        }


// ---------------------------------------------------------
// CLensflare::GetTimeTick
// Returns the current time.
// ---------------------------------------------------------
TTime CLensflare::GetTimeTick()
        {
        TTime time;
        time.UniversalTime();
   
        return time;
        }
        
// ---------------------------------------------------------
// CLensflare::GetElapsedTime
// Returns the time (in sec.) between current and previous frame.
// ---------------------------------------------------------
GLfloat CLensflare::GetElapsedTime()
        { 
        return iElapsedTime;
        }

// ---------------------------------------------------------
// CLensflare::GetFPSCount
// Returns the current frame rate.
// ---------------------------------------------------------
GLfloat CLensflare::GetFPSCount() 
        {
        return iFPSCount;
        }

// ---------------------------------------------------------
// CLensflare::MoveCamera
// Move the camera from/to the origin.
// ---------------------------------------------------------
void CLensflare::MoveCamera(GLint aDirection, GLfloat aTime)
        {
        if ( aTime == 0 )
                {
                aTime = iElapsedTime;
                }
        iDistance += (aDirection * 20 * aTime);
        }

// ---------------------------------------------------------
// CLensflare::TurnCameraAzimuth
// Turn the camera in azimuth.
// ---------------------------------------------------------
void CLensflare::TurnCameraAzimuth(GLint aDirection, GLfloat aTime)
        {
        if ( aTime == 0 )
                {
                aTime = iElapsedTime;
                }
        iAzimuth += (aDirection * 20 * aTime);
        if ( iAzimuth < 0 )
                {
                iAzimuth = 359;
                }
        else if ( iAzimuth > 359 )
                {
                iAzimuth = 0;
                }
        else
                {
                }
        }

// ---------------------------------------------------------
// CLensflare::TurnCameraElevation
// Turn the camera in elevation.
// ---------------------------------------------------------
void CLensflare::TurnCameraElevation(GLint aDirection, GLfloat aTime)
        {
        if ( aTime == 0 )
                {
                aTime = iElapsedTime;
                }
        iElevation += ( aDirection * 20 * aTime);
        if ( iElevation < 5 )
                {
                iElevation = 5;
                }
        else if ( iElevation > 175 )
                {
                iElevation = 175;
                }
        else
                {
                }
        }


// -------------------------------------------------------------------------------------------------------
// CLensflare::OnStartLoadingTextures()
// Called for a MTextureLoadingListener by the texture manager when texture loading operation starts 
// -------------------------------------------------------------------------------------------------------
void CLensflare::OnStartLoadingTexturesL()
        {
    SetStateL( ELoadingTextures );
        }

// ------------------------------------------------------------------------------------------------------------
// CLensflare::OnEndLoadingTextures()
// Called for a MTextureLoadingListener by the texture manager when texture loading operation is completed
// ------------------------------------------------------------------------------------------------------------

void CLensflare::OnEndLoadingTexturesL()
        {
        if ( GetState() == ELoadingTextures )
                {
                SetStateL( ERunning );
                }
        }

// ---------------------------------------------------------
// CLensflare::OnEnterState( TInt aState )
// Called by CFiniteStateMachine when the f.s.m enters a new state.
// ---------------------------------------------------------

void CLensflare::OnEnterStateL( TInt aState )
        {
    switch ( aState )
                {
                case ERunning:
                        iT1 = GetTimeTick();
                        break;
                default:
              break;
                }
        }

// -----------------------------------------------------------------------------
// CLensflare::SetScreenSize
// Reacts to the dynamic screen size change during execution of this program.
// -----------------------------------------------------------------------------
//
void CLensflare::SetScreenSize( TUint aWidth, TUint aHeight )
    {
    iScreenWidth  = aWidth;
    iScreenHeight = aHeight;
    
    // Notify the texture manager of screen size change
    iTextureManager->SetScreenSize( aWidth, aHeight );

    // Reinitialize viewport and projection.
    glViewport( 0, 0, iScreenWidth, iScreenHeight );

    // Recalculate the view frustrum
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    GLfloat aspectRatio = (GLfloat)(iScreenWidth) / (GLfloat)(iScreenHeight);
    glFrustumf( FRUSTUM_LEFT * aspectRatio, FRUSTUM_RIGHT * aspectRatio,
                FRUSTUM_BOTTOM, FRUSTUM_TOP,
                FRUSTUM_NEAR, FRUSTUM_FAR );
    glMatrixMode( GL_MODELVIEW );
    }

---

© Nokia 2006