CSnow Class Reference

00172                 { 
00173                 ELoadingTextures, 
00174                 ERunning 
00175                 };

00391         : CFiniteStateMachine()
00392         {
00393     iScreenWidth  = aWidth;
00394     iScreenHeight = aHeight;
00395 
00396         }

00121         {
00122     /* Symbian 2-phase constructor. Calls both the default 
00123        C++ constructor and Symbian ConstructL methods */
00124     CSnow* self = new (ELeave) CSnow( aWidth, aHeight );
00125     CleanupStack::PushL( self );
00126     self->ConstructL();
00127     CleanupStack::Pop();
00128 
00129     return self;
00130         }

00176         {
00177     /* Set the screen background color. */
00178     glClearColor( 0.f, 0.f, 0.f, 1.f );
00179 
00180     /* Enable back face culling. */
00181     glEnable( GL_CULL_FACE  );
00182     glEnable( GL_TEXTURE_2D );
00183     glEnable( GL_DEPTH_TEST );
00184 
00185     //Enable alpha test for color keying.
00186     glEnable( GL_ALPHA_TEST );
00187     glAlphaFunc( GL_GREATER, 0.0f );
00188 
00189     /*Disable lighting */
00190     glDisable( GL_LIGHTING );
00191 
00192     /* Initialize viewport and projection. */
00193     glViewport( 0, 0, iScreenWidth, iScreenHeight );
00194     glMatrixMode( GL_PROJECTION );
00195 
00196     // Calculate the view frustrum
00197     GLfloat aspectRatio = (GLfloat)(iScreenWidth) / (GLfloat)(iScreenHeight);
00198     glFrustumf( FRUSTUM_LEFT * aspectRatio, FRUSTUM_RIGHT * aspectRatio,
00199                 FRUSTUM_BOTTOM, FRUSTUM_TOP,
00200                 FRUSTUM_NEAR, FRUSTUM_FAR );
00201 
00202     // Calculate cloud vertices based on the aspect ratio
00203     iCloudVertices[ 0 ] = FRUSTUM_RIGHT * aspectRatio;
00204     iCloudVertices[ 1 ] = 0.f;
00205     iCloudVertices[ 2 ] = -FRUSTUM_NEAR;
00206 
00207     iCloudVertices[ 3 ] = FRUSTUM_RIGHT * aspectRatio;
00208     iCloudVertices[ 4 ] = FRUSTUM_TOP;
00209     iCloudVertices[ 5 ] = -FRUSTUM_NEAR;
00210 
00211     iCloudVertices[ 6 ] = FRUSTUM_LEFT * aspectRatio;
00212     iCloudVertices[ 7 ] = FRUSTUM_TOP;
00213     iCloudVertices[ 8 ] = -FRUSTUM_NEAR;
00214 
00215     iCloudVertices[ 9 ] = FRUSTUM_LEFT * aspectRatio;
00216     iCloudVertices[ 10 ] = 0.f;
00217     iCloudVertices[ 11 ] = -FRUSTUM_NEAR;
00218 
00219     glMatrixMode( GL_MODELVIEW );
00220 
00221     /* Enable vertex arrays. */
00222     glEnableClientState( GL_VERTEX_ARRAY );
00223     /* Enable texture arrays. */
00224     glEnableClientState( GL_TEXTURE_COORD_ARRAY );
00225 
00226     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00227     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00228 
00229 
00230     iCloudTextureCoords[0] = 0; iCloudTextureCoords[1] = 1; 
00231     iCloudTextureCoords[2] = 0; iCloudTextureCoords[3] = 0; 
00232     iCloudTextureCoords[4] = 1; iCloudTextureCoords[5] = 0; 
00233     iCloudTextureCoords[6] = 1; iCloudTextureCoords[7] = 1; 
00234 
00235     iCamera.LookAt(TVector(0, 30.0f, 0), TVector(0, 0, -(FRUSTUM_FAR+FRUSTUM_NEAR)/2), TVector(0, 1, 0));
00236  
00237     // Construct a texture manager that uses the application's private
00238         // directory as the source location for all textures.
00239     iTextureManager = CTextureManager::NewL ( iScreenWidth, iScreenWidth,
00240                                               FRUSTUM_TOP, FRUSTUM_BOTTOM, FRUSTUM_RIGHT, FRUSTUM_LEFT, FRUSTUM_NEAR,                               
00241                                               this );
00242     iSnowfall = CSnowfall::NewL(600, TVector(0, 80, -(FRUSTUM_FAR+FRUSTUM_NEAR)/2), 120, (FRUSTUM_FAR-FRUSTUM_NEAR), 0, iTextureManager);
00243 
00244     // Defining a color key interval for the tree texture.
00245     TUint8 MinColor[] = { 50, 0, 50 };
00246     TUint8 MaxColor[] = { 255, 75, 255 };
00247     
00248     // Pushing the textures into the loading queue.
00249         _LIT(KSnowyTreeName, "snowy_tree.gif");
00250         _LIT(KSnowyGroundName, "snowy_ground.jpg");
00251         _LIT(KCloudName, "cloud.jpg");
00252     iTextureManager->RequestToLoad(KSnowyTreeName, &iTreeTexture, MinColor, MaxColor );
00253     iTextureManager->RequestToLoad(KSnowyGroundName, &iGroundTexture );
00254     iTextureManager->RequestToLoad(KCloudName, &iCloudTexture );
00255 
00256     //Start to load the textures.
00257     iTextureManager->DoLoadL();
00258         }

00266         {
00267     delete iSnowfall;
00268     delete iTextureManager;
00269         }

00350         {
00351     glClear( GL_DEPTH_BUFFER_BIT );
00352 
00353     iT0 = iT1;
00354     do 
00355                 {
00356         iT1 = GetTimeTick();
00357         //Compute the elapsed time (in sec.) between the current and the previous frame.
00358         iElapsedTime = I64LOW( iT1.MicroSecondsFrom( iT0 ).Int64() * ( 1 / 1000000.0f ) );
00359                 } while ( iElapsedTime == 0 );                   
00360     
00361         iFPSCount = 1 / (iElapsedTime);        //Compute the frame rate.
00362 
00363     /* Draws the clouds, and the ground plane */
00364     glDisable( GL_DEPTH_TEST );
00365     DrawCloud();
00366     DrawPlane();
00367 
00368     const TReal32 treeStepX = 30.0f;
00369     const TReal32 treeStepZ = 100.0f;
00370 
00371     //Draw the trees.
00372     DrawTree( -treeStepX, -1*treeStepZ);
00373     DrawTree( +treeStepX, -1*treeStepZ);
00374     DrawTree( -treeStepX, -2*treeStepZ);
00375     DrawTree( +treeStepX, -2*treeStepZ);
00376 
00377     glEnable( GL_DEPTH_TEST );
00378 
00379     /*Update and render the particle engine */
00380     iSnowfall->UpdateEngine(iElapsedTime);
00381     iSnowfall->RenderEngine(iCamera);
00382         }

00412         {
00413     if ( aState == ERunning )
00414                 {
00415         iT1 = GetTimeTick();
00416                 }
00417         }

00425         {
00426     SetStateL( ELoadingTextures );
00427         }

00434         {
00435         if ( GetState() == ELoadingTextures )
00436                 {
00437         SetStateL( ERunning );
00438                 }
00439         }

00277         {
00278     glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE );
00279 
00280     glBindTexture(  GL_TEXTURE_2D, iGroundTexture.iID );
00281     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_NEAREST);
00282     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_NEAREST);
00283 
00284     glLoadIdentity();
00285     T3DModel::MakeWorldViewMatrix(iCamera, TVector(0.0f, 0.0f, 0.0f));
00286     glScalef( 1000, 0, 1000 );
00287 
00288 
00289     glVertexPointer( 3, GL_BYTE, 0, planeVertices );
00290     glTexCoordPointer( 2, GL_BYTE, 0, planeTextureCoords );
00291     glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, planeTriangles );
00292 
00293     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00294     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00295 
00296     glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST );
00297         }

00330         {
00331     glLoadIdentity();
00332 
00333     //Turns the tree so that it always faces the camera.
00334     T3DModel::MakeBillboardWorldViewMatrix(iCamera, TVector(aX, 0.0f, aZ));
00335     glScalef( 10, 30, 10 );
00336 
00337     glBindTexture(  GL_TEXTURE_2D, iTreeTexture.iID );
00338     
00339     glVertexPointer( 3, GL_BYTE, 0, treeVertices );
00340     glTexCoordPointer( 2, GL_BYTE, 0, treeTextureCoords );
00341     glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, treeTriangles );
00342         }

00305         {
00306     iTextureOffset += (GLfloat)(0.01*iElapsedTime);
00307 
00308     iCloudTextureCoords[0] = iCloudTextureCoords[2] = iTextureOffset;
00309     iCloudTextureCoords[4] = iCloudTextureCoords[6] = iTextureOffset + 0.4f;
00310 
00311     glDisable( GL_DEPTH_TEST );
00312 
00313     glLoadIdentity();
00314 
00315     glBindTexture(  GL_TEXTURE_2D, iCloudTexture.iID );
00316 
00317     glVertexPointer( 3, GL_FLOAT, 0, iCloudVertices );
00318     glTexCoordPointer( 2, GL_FLOAT, 0, iCloudTextureCoords );
00319     glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, cloudTriangles );
00320 
00321     glEnable( GL_DEPTH_TEST );
00322         }

00166         { 
00167         return iSnowfall;
00168         }

00448 {
00449    TTime time;
00450    time.UniversalTime();
00451    
00452    return time;
00453 }

00144         { 
00145         return iElapsedTime; 
00146         }

00155         { 
00156         return iFPSCount; 
00157         }

00461     {
00462     iScreenWidth  = aWidth;
00463     iScreenHeight = aHeight;
00464     
00465     // Notify the texture manager of screen size change
00466     iTextureManager->SetScreenSize( aWidth, aHeight );
00467 
00468     // Reinitialize viewport and projection.
00469     glViewport( 0, 0, iScreenWidth, iScreenHeight );
00470 
00471     // Recalculate the view frustrum
00472     glMatrixMode( GL_PROJECTION );
00473     glLoadIdentity();
00474     GLfloat aspectRatio = (GLfloat)(iScreenWidth) / (GLfloat)(iScreenHeight);
00475     glFrustumf( FRUSTUM_LEFT * aspectRatio, FRUSTUM_RIGHT * aspectRatio,
00476                 FRUSTUM_BOTTOM, FRUSTUM_TOP,
00477                 FRUSTUM_NEAR, FRUSTUM_FAR );
00478     glMatrixMode( GL_MODELVIEW );
00479 
00480     // Recalculate cloud vertices based on the aspect ratio
00481     iCloudVertices[ 0 ] = FRUSTUM_RIGHT * aspectRatio;
00482     iCloudVertices[ 1 ] = 0.f;
00483     iCloudVertices[ 2 ] = -FRUSTUM_NEAR;
00484 
00485     iCloudVertices[ 3 ] = FRUSTUM_RIGHT * aspectRatio;
00486     iCloudVertices[ 4 ] = FRUSTUM_TOP;
00487     iCloudVertices[ 5 ] = -FRUSTUM_NEAR;
00488 
00489     iCloudVertices[ 6 ] = FRUSTUM_LEFT * aspectRatio;
00490     iCloudVertices[ 7 ] = FRUSTUM_TOP;
00491     iCloudVertices[ 8 ] = -FRUSTUM_NEAR;
00492 
00493     iCloudVertices[ 9 ] = FRUSTUM_LEFT * aspectRatio;
00494     iCloudVertices[ 10 ] = 0.f;
00495     iCloudVertices[ 11 ] = -FRUSTUM_NEAR;
00496     }


Public Types
enum	{ ELoadingTextures, ERunning }
Public Member Functions
virtual	~CSnow ()
void	AppInitL (void)
void	AppExit (void)
void	AppCycle (TInt aFrame)
void	OnEnterStateL (TInt aState)
void	OnStartLoadingTexturesL ()
void	OnEndLoadingTexturesL ()
void	DrawPlane ()
void	DrawTree (GLfloat aX, GLfloat aZ)
void	DrawCloud ()
CSnowfall *	GetSnowfall ()
TTime	GetTimeTick ()
GLfloat	GetElapsedTime ()
GLfloat	GetFPSCount ()
void	SetScreenSize (TUint aWidth, TUint aHeight)
Static Public Member Functions
static CSnow *	NewL (TUint aWidth, TUint aHeight)
Protected Member Functions
	CSnow (TUint aWidth, TUint aHeight)
void	ConstructL (void)
Private Attributes
CTextureManager *	iTextureManager
TUint	iScreenWidth
TUint	iScreenHeight
TTexture	iTreeTexture
TTexture	iGroundTexture
TTexture	iCloudTexture
GLfloat	iCloudTextureCoords [8]
GLfloat	iTextureOffset
CSnowfall *	iSnowfall
TCamera	iCamera
TTime	iT0
TTime	iT1
GLfloat	iElapsedTime
GLfloat	iFPSCount
GLfloat	iCloudVertices [12]

CSnow Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation