S60 3rd Edition SDK for Symbian OS Example Applications Guide

Billboard.cpp

/*
* ==============================================================================
*  Name        : Billboard.cpp
*  Part of     : OpenGLEx / Billboard
*  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 "billboard.h"
#include <aknnotewrappers.h> 
#include <e32math.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS
const TInt KNumberOfTreeInRow = 10; //Number of trees in a row.
const TInt KNumberOfTreeInCol = 10; //Number of trees in a col.
const GLint KTreeStep = 10;         //Min. Distance between two trees.

/* 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 texture coordinates for ground plane */
static const GLshort planeTextureCoords[4 * 2] =
        {
        0,    0,
        0, 1000,
     1000, 1000,
     1000,    0
        };
 

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


/* Define vertice coordinates for drawing the trees */
static const GLbyte treeVertices[4 * 3] =
        {
    +1,  0, 0,
    +1, +1, 0,
    -1, +1, 0,
    -1,  0, 0
        };

/* Define texture coordinates for drawing the trees */
static const GLbyte treeTextureCoords[4 * 2] =
        {
      0, 100,
      0,   0,
    100,   0,
    100, 100
        };

/* Define indices for drawing the trees */
static const GLubyte treeTriangles[2 * 3] =
        {
    0,1,2,
    0,2,3
        };

/* Define indices for drawing the clouds */
static const GLubyte cloudTriangles [] =
        {
    0,1,2,
    0,2,3
        };

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

    return self;
        }

//  Destructor. 
CBillboard::~CBillboard()
        {
        }

// -----------------------------------------------------------------------------
// CBillboard::AppInit
// Initializes the application.
// -----------------------------------------------------------------------------
//
void CBillboard::AppInitL( void )
        {
    /* Set the screen background color. */
    glClearColor( 0.f, 0.f, 0.f, 1.f );

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

    /*Disable lighting */
    glDisable( GL_LIGHTING );

    //Enable alpha test for color keying.
    glEnable( GL_ALPHA_TEST );
    glAlphaFuncx( GL_GREATER, FLOAT_2_FIXED(0.0f));

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

    // Calculate cloud vertices based on the aspect ratio
    iCloudVertices[ 0 ] = FRUSTUM_RIGHT * aspectRatio;
    iCloudVertices[ 1 ] = 0.f;
    iCloudVertices[ 2 ] = -FRUSTUM_NEAR;

    iCloudVertices[ 3 ] = FRUSTUM_RIGHT * aspectRatio;
    iCloudVertices[ 4 ] = FRUSTUM_TOP;
    iCloudVertices[ 5 ] = -FRUSTUM_NEAR;

    iCloudVertices[ 6 ] = FRUSTUM_LEFT * aspectRatio;
    iCloudVertices[ 7 ] = FRUSTUM_TOP;
    iCloudVertices[ 8 ] = -FRUSTUM_NEAR;

    iCloudVertices[ 9 ] = FRUSTUM_LEFT * aspectRatio;
    iCloudVertices[ 10 ] = 0.f;
    iCloudVertices[ 11 ] = -FRUSTUM_NEAR;


    glMatrixMode( GL_TEXTURE );
    glLoadIdentity();
    glScalex(FIXED_DIV(FIXED_ONE, INT_2_FIXED(100)), FIXED_DIV(FIXED_ONE, INT_2_FIXED(100)), FIXED_ONE );


    glMatrixMode( GL_MODELVIEW );

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

    glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    iCloudTextureCoords[0] =   0; iCloudTextureCoords[1] = 100; 
    iCloudTextureCoords[2] =   0; iCloudTextureCoords[3] =   0; 
    iCloudTextureCoords[4] = 100; iCloudTextureCoords[5] =   0; 
    iCloudTextureCoords[6] = 100; iCloudTextureCoords[7] = 100; 

    iDistance = INT_2_FIXED(40);
    iDirection = +1;

    iLookUpTable = CLookUpTable::NewL( CLookUpTable::ESinx | CLookUpTable::ECosx );

        // Construct a texture manager that uses the application's private
        // directory as the location for all textures.
    iTextureManager = CTextureManager::NewL ( iScreenWidth, iScreenWidth,
                                              FRUSTUM_TOP, FRUSTUM_BOTTOM, FRUSTUM_RIGHT, FRUSTUM_LEFT, FRUSTUM_NEAR,                               
                                              this );
    
    // Defining a color key interval for the tree texture.
    TUint8 MinColor[] = {  50, 0,  50};
    TUint8 MaxColor[] = { 200, 0, 200};
    
    // Pushing the textures into the loading queue.
    _LIT(KTreeTexture, "tree.gif");
    _LIT(KGrassTexture, "grass.jpg");
    _LIT(KCloudTexture, "cloud.jpg");
    iTextureManager->RequestToLoad( KTreeTexture , &iTreeTexture, MinColor, MaxColor );
    iTextureManager->RequestToLoad( KGrassTexture, &iGrassTexture );
    iTextureManager->RequestToLoad( KCloudTexture, &iCloudTexture );

    //Start to load the textures.
    iTextureManager->DoLoadL();
        }

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

// -----------------------------------------------------------------------------
// CBillboard::DrawPlane
// Draw the ground plane.
// -----------------------------------------------------------------------------
//
void CBillboard::DrawPlane( TInt /*aFrame*/ )
        {
    glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE );

    glBindTexture(  GL_TEXTURE_2D, iGrassTexture.iID );

    glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    
    glLoadIdentity();
    T3DModelx::MakeWorldViewMatrix(iCamera, TVectorx(INT_2_FIXED(0), INT_2_FIXED(0), INT_2_FIXED(0)));
    glScalex( INT_2_FIXED(100), INT_2_FIXED(0), INT_2_FIXED(100) );

    glVertexPointer( 3, GL_BYTE, 0, planeVertices );
    glTexCoordPointer( 2, GL_SHORT, 0, planeTextureCoords );
    glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, planeTriangles );

    glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST );
        }

// -----------------------------------------------------------------------------
// CBillboard::DrawCloud
// Draw clouds.
// -----------------------------------------------------------------------------
//
void CBillboard::DrawCloud( TInt /*aFrame*/ )
        {
    //Moving the clouds.
    iTextureOffset = (GLshort)(iTextureOffset + 10 * iDirection * FIXED_2_FLOAT(iElapsedTime));
    iCloudTextureCoords[0] = iCloudTextureCoords[2] = iTextureOffset;
    iCloudTextureCoords[4] = iCloudTextureCoords[6] = (GLshort)(iTextureOffset+40);

    glLoadIdentity();

    glBindTexture( GL_TEXTURE_2D, iCloudTexture.iID );

        glVertexPointer( 3, GL_FLOAT, 0, iCloudVertices );
    glTexCoordPointer( 2, GL_SHORT, 0, iCloudTextureCoords );
    glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, cloudTriangles );
        }

// -----------------------------------------------------------------------------
// CBillboard::DrawTree
// Draw a tree.
// -----------------------------------------------------------------------------
//
void CBillboard::DrawTree( TInt /*aFrame*/, TInt aI, TInt aJ)
        {
    GLint x = KTreeStep * (aJ - (KNumberOfTreeInCol >> 1));
    GLint z = KTreeStep * (aI - (KNumberOfTreeInRow >> 1));

    glLoadIdentity();
    
    // Turns the tree so that it always faces the camera. (Billboarding technique)
    T3DModelx::MakeBillboardWorldViewMatrix(iCamera, TVectorx(INT_2_FIXED(x), INT_2_FIXED(0), INT_2_FIXED(z)));
    glScalex( INT_2_FIXED(1), INT_2_FIXED(3), INT_2_FIXED(1) );

    glBindTexture(  GL_TEXTURE_2D, iTreeTexture.iID );
    
    glVertexPointer(   3, GL_BYTE, 0, treeVertices );
    glTexCoordPointer( 2, GL_BYTE, 0, treeTextureCoords );
    glDrawElements(    GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, treeTriangles );
        }


// -----------------------------------------------------------------------------
// CBillboard::AppCycle
// Draws and animates the objects.
// @param aFrame Current frame number.
// -----------------------------------------------------------------------------
//
void CBillboard::AppCycle( TInt aFrame )
        {
        glClear( GL_DEPTH_BUFFER_BIT );

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

        //Compute the frame rate
    iFPSCount = FIXED_DIV(FIXED_ONE, iElapsedTime);

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

    GLfixed sin = iLookUpTable->Sinx(iAzimuth),
            cos = iLookUpTable->Cosx(iAzimuth);

    GLfixed x = FIXED_MUL(iDistance, cos);
    GLfixed z = FIXED_MUL(iDistance, sin);

    iCamera.LookAt(TVectorx(x, INT_2_FIXED(3), z),
                   TVectorx(INT_2_FIXED(0), INT_2_FIXED(0),  INT_2_FIXED(0)),
                   TVectorx(INT_2_FIXED(0), INT_2_FIXED(1),  INT_2_FIXED(0)));

    /* Draws the clouds, the gound plane and the trees */
    glDisable( GL_DEPTH_TEST );
    DrawCloud( aFrame );
    DrawPlane( aFrame );
    glEnable( GL_DEPTH_TEST );

    for ( TInt i = 0;i < KNumberOfTreeInRow; i++ )
        {
        for ( TInt j = 0;j < KNumberOfTreeInCol; j++ )
                        {
                        DrawTree( aFrame, i, j);
                        }
        }
        }

// -----------------------------------------------------------------------------
// CBillboard::CBillBoard
// Default C++ and Symbian ConstructL are placed in protected
// area to force the use of NewL when creating an instance.
// -----------------------------------------------------------------------------
//
CBillboard::CBillboard( TUint aWidth, TUint aHeight )
        : CFiniteStateMachine()
        {
    iScreenWidth  = aWidth;
    iScreenHeight = aHeight;
        }

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

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

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

                default:
                  break;
                }
        }

// -------------------------------------------------------------------------------------------------------
// CBillboard::OnStartLoadingTextures()
// Called for a MTextureLoadingListener by the texture manager when texture loading operation starts 
// -------------------------------------------------------------------------------------------------------

void CBillboard::OnStartLoadingTexturesL()
        {
    SetStateL( ELoadingTextures );
        }

// ------------------------------------------------------------------------------------------------------------
// CBillboard::OnEndLoadingTextures()
// Called for a MTextureLoadingListener by the texture manager when texture loading operation is completed
// ------------------------------------------------------------------------------------------------------------
void CBillboard::OnEndLoadingTexturesL()
        {
        if ( GetState() == ELoadingTextures )
                {
                SetStateL( ERunning );
                }
        }

// ------------------------------------------------------------------------------------------------------------
// CBillboard::GetTimeTick()
// Returns the current time.
// ------------------------------------------------------------------------------------------------------------
TTime CBillboard::GetTimeTick()
        {
        TTime time;
        time.UniversalTime();
        
        return time;
        }

// ------------------------------------------------------------------------------------------------------------
// CBillboard::GetElapsedTime()
// Returns the ellapsed time (in sec.) between the current and the previous frame.
// ------------------------------------------------------------------------------------------------------------
GLfixed CBillboard::GetElapsedTime() 
        {
        return iElapsedTime; 
        }

// ------------------------------------------------------------------------------------------------------------
// CBillboard::GetFPSCount()
// Returns the current frame rate in f.p.s
// ------------------------------------------------------------------------------------------------------------
GLfixed CBillboard::GetFPSCount() 
        { 
        return iFPSCount; 
        }

// -----------------------------------------------------------------------------
// CBillboard::SetScreenSize
// Reacts to the dynamic screen size change during execution of this program.
// -----------------------------------------------------------------------------
//
void CBillboard::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 );

    // Recalculate cloud vertices based on the aspect ratio
    iCloudVertices[ 0 ] = FRUSTUM_RIGHT * aspectRatio;
    iCloudVertices[ 1 ] = 0.f;
    iCloudVertices[ 2 ] = -FRUSTUM_NEAR;

    iCloudVertices[ 3 ] = FRUSTUM_RIGHT * aspectRatio;
    iCloudVertices[ 4 ] = FRUSTUM_TOP;
    iCloudVertices[ 5 ] = -FRUSTUM_NEAR;

    iCloudVertices[ 6 ] = FRUSTUM_LEFT * aspectRatio;
    iCloudVertices[ 7 ] = FRUSTUM_TOP;
    iCloudVertices[ 8 ] = -FRUSTUM_NEAR;

    iCloudVertices[ 9 ] = FRUSTUM_LEFT * aspectRatio;
    iCloudVertices[ 10 ] = 0.f;
    iCloudVertices[ 11 ] = -FRUSTUM_NEAR;
    }

// ------------------------------------------------------------------------------------------------------------
// CBillboard::MoveCamera()
// Move the camera from/to the origin.
// ------------------------------------------------------------------------------------------------------------
void CBillboard::MoveCamera(GLint aDirection, GLfixed aTime)
        {
        if ( aTime == 0 )
                {
                aTime = iElapsedTime;
                }
        iDistance += FIXED_MUL(INT_2_FIXED(aDirection * 3), aTime);
        if ( iDistance < INT_2_FIXED(-100) )
                {
                iDistance = INT_2_FIXED(-100);
                }
        if ( iDistance > INT_2_FIXED(+100) )
                {
                iDistance = INT_2_FIXED(+100);
                }
    }

// ------------------------------------------------------------------------------------------------------------
// CBillboard::TurnCamera()
// Turn the camera in azimuth.
// ------------------------------------------------------------------------------------------------------------
void CBillboard::TurnCamera(GLint aDirection, GLfixed aTime)
        {
        if ( aTime == 0 )
                {
                aTime = iElapsedTime;
                }
    iAzimuth += FIXED_MUL(INT_2_FIXED(aDirection * 10), aTime);
     //Keeping the azimuth within [0, 359]
    if ( iAzimuth < 0 )
        {
        iAzimuth = INT_2_FIXED(+359);
        }
    else if ( iAzimuth > INT_2_FIXED(+359) )
        {
        iAzimuth = 0; 
        }
    else 
        {
        }
        }

---

© Nokia 2006