CRain Class Reference

00170                 { 
00171                 ELoadingTextures, 
00172                 ERunning 
00173                 };

00338     : CFiniteStateMachine()
00339         {
00340         iScreenWidth  = aWidth;
00341         iScreenHeight = aHeight;
00342 
00343         }

00105         {
00106         /* Symbian 2-phase constructor. Calls both the default 
00107            C++ constructor and Symbian ConstructL methods */
00108         CRain* self = new (ELeave) CRain( aWidth, aHeight );
00109         CleanupStack::PushL( self );
00110         self->ConstructL();
00111         CleanupStack::Pop();
00112 
00113         return self;
00114         }

00129         {
00130         /* Set the screen background color. */
00131         glClearColor( 0.f, 0.f, 0.f, 1.f );
00132 
00133         /* Enable back face culling. */
00134         glEnable( GL_CULL_FACE  );
00135     glEnable( GL_TEXTURE_2D );
00136         glEnable( GL_DEPTH_TEST );
00137 
00138         //Enable alpha test for color keying.
00139         glEnable( GL_ALPHA_TEST );
00140         glAlphaFunc( GL_GREATER, 0.0f );
00141 
00142         /*Disable lighting */
00143         glDisable( GL_LIGHTING );
00144 
00145         /* Initialize viewport and projection. */
00146         glViewport( 0, 0, iScreenWidth, iScreenHeight );
00147     glMatrixMode( GL_PROJECTION );
00148     GLfloat aspectRatio = (GLfloat)(iScreenWidth) / (GLfloat)(iScreenHeight);
00149     glFrustumf( FRUSTUM_LEFT * aspectRatio, FRUSTUM_RIGHT * aspectRatio,
00150                 FRUSTUM_BOTTOM, FRUSTUM_TOP,
00151                 FRUSTUM_NEAR, FRUSTUM_FAR );
00152 
00153 
00154     // Calculate cloud vertices based on the aspect ratio
00155     iCloudVertices[ 0 ] = FRUSTUM_RIGHT * aspectRatio;
00156     iCloudVertices[ 1 ] = 0.f;
00157     iCloudVertices[ 2 ] = -FRUSTUM_NEAR;
00158 
00159     iCloudVertices[ 3 ] = FRUSTUM_RIGHT * aspectRatio;
00160     iCloudVertices[ 4 ] = FRUSTUM_TOP;
00161     iCloudVertices[ 5 ] = -FRUSTUM_NEAR;
00162 
00163     iCloudVertices[ 6 ] = FRUSTUM_LEFT * aspectRatio;
00164     iCloudVertices[ 7 ] = FRUSTUM_TOP;
00165     iCloudVertices[ 8 ] = -FRUSTUM_NEAR;
00166 
00167     iCloudVertices[ 9 ] = FRUSTUM_LEFT * aspectRatio;
00168     iCloudVertices[ 10 ] = 0.f;
00169     iCloudVertices[ 11 ] = -FRUSTUM_NEAR;
00170 
00171 
00172         glMatrixMode( GL_MODELVIEW );
00173 
00174         /* Enable vertex arrays. */
00175         glEnableClientState( GL_VERTEX_ARRAY );
00176     /* Enable texture arrays. */
00177         glEnableClientState( GL_TEXTURE_COORD_ARRAY );
00178 
00179     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00180     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00181 
00182         iCloudTextureCoords[0] = 0; iCloudTextureCoords[1] = 1; 
00183         iCloudTextureCoords[2] = 0; iCloudTextureCoords[3] = 0; 
00184         iCloudTextureCoords[4] = 1; iCloudTextureCoords[5] = 0; 
00185         iCloudTextureCoords[6] = 1; iCloudTextureCoords[7] = 1; 
00186 
00187         iRainfall = CRainfall::NewL(1000, TVector(0, 80, -(FRUSTUM_FAR+FRUSTUM_NEAR)/2), 120, (FRUSTUM_FAR-FRUSTUM_NEAR), 0);
00188         
00189         iCamera.LookAt(TVector(0, 30.0f, 0), TVector(0, 0, -(FRUSTUM_FAR+FRUSTUM_NEAR)/2), TVector(0, 1, 0));
00190 
00191         // Construct a texture manager that uses the application's private
00192         // directory as the source location for all textures.
00193         iTextureManager = CTextureManager::NewL( iScreenWidth, iScreenWidth,
00194                                                                                          FRUSTUM_TOP, FRUSTUM_BOTTOM, FRUSTUM_RIGHT, FRUSTUM_LEFT, FRUSTUM_NEAR,                                                                
00195                                                      this );
00196 
00197     // Defining a color key interval for the tree texture.
00198         TUint8 MinColor[] = { 50, 0, 50};
00199         TUint8 MaxColor[] = { 200, 0, 200};
00200         
00201         // Pushing the textures into the loading queue.
00202         _LIT(KTreeName, "tree.gif");
00203         _LIT(KGrassName, "grass.jpg");
00204         _LIT(KCloudName, "cloud.jpg");
00205 
00206         iTextureManager->RequestToLoad(KTreeName , &iTreeTexture, MinColor, MaxColor );
00207         iTextureManager->RequestToLoad(KGrassName, &iGrassTexture );
00208         iTextureManager->RequestToLoad(KCloudName, &iCloudTexture );
00209 
00210         //Start to load the textures.
00211         iTextureManager->DoLoadL();
00212         }

00220         {
00221         delete iRainfall;
00222         delete iTextureManager;
00223         }

00301         {
00302     glClear( GL_DEPTH_BUFFER_BIT );
00303 
00304     iT0 = iT1;
00305         do 
00306                 {
00307                 iT1 = GetTimeTick();
00308                 //Compute the Elapsed time (in sec.) between the current and the previous frame.
00309         iElapsedTime = I64LOW( iT1.MicroSecondsFrom( iT0 ).Int64() * ( 1 / 1000000.0f ) );
00310                 } while ( iElapsedTime == 0 );
00311         iFPSCount = 1 / (iElapsedTime);        //Compute the frame rate.
00312 
00313         /* Draws the clouds, and the ground plane */
00314     glDisable( GL_DEPTH_TEST );
00315         DrawCloud();
00316         DrawPlane();
00317 
00318         //Draw the trees.
00319         DrawTree( -TREE_STEP_X, -1*TREE_STEP_Z);
00320     DrawTree( +TREE_STEP_X, -1*TREE_STEP_Z);
00321         DrawTree( -TREE_STEP_X, -2*TREE_STEP_Z);
00322     DrawTree( +TREE_STEP_X, -2*TREE_STEP_Z);
00323 
00324         glEnable( GL_DEPTH_TEST );
00325 
00326         /*Update and render the particle engine */
00327         iRainfall->UpdateEngine(iElapsedTime);
00328     iRainfall->RenderEngine(iCamera);
00329         }

00359         {
00360         switch ( aState )
00361                 {
00362                 case ERunning:
00363                     iT1 = GetTimeTick(); 
00364                         break;
00365                 default:
00366                         break;
00367                 }
00368         }

00376         {
00377         SetStateL( ELoadingTextures );
00378         }

00386         {
00387         if ( GetState() == ELoadingTextures )
00388                 {
00389                 SetStateL( ERunning );
00390                 }
00391         }

00231         {
00232         glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE );
00233 
00234     glBindTexture(  GL_TEXTURE_2D, iGrassTexture.iID );
00235 
00236     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_NEAREST);
00237         glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_NEAREST);
00238         
00239     glLoadIdentity();
00240         T3DModel::MakeWorldViewMatrix(iCamera, TVector(0.0f, 0.0f, 0.0f));
00241         glScalef( 1000, 0, 1000 );
00242 
00243     glVertexPointer( 3, GL_BYTE, 0, planeVertices );
00244         glTexCoordPointer( 2, GL_BYTE, 0, planeTextureCoords );
00245     glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, planeTriangles );
00246 
00247     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00248         glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00249 
00250         glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST );
00251         }

00279         {
00280     glLoadIdentity();
00281         
00282         //Turns the tree so that it always faces the camera.
00283         T3DModel::MakeBillboardWorldViewMatrix(iCamera, TVector(aX, 0.0f, aZ));
00284         glScalef( 10, 30, 10 );
00285 
00286     glBindTexture(  GL_TEXTURE_2D, iTreeTexture.iID );
00287     
00288         glVertexPointer( 3, GL_BYTE, 0, treeVertices );
00289         glTexCoordPointer( 2, GL_BYTE, 0, treeTextureCoords );
00290     glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, treeTriangles );
00291 
00292         }

00259         {
00260     iTextureOffset += (GLfloat)(0.01 * iElapsedTime);
00261 
00262         iCloudTextureCoords[0] = iCloudTextureCoords[2]= iTextureOffset;
00263     iCloudTextureCoords[4] = iCloudTextureCoords[6]= iTextureOffset+0.4f;
00264 
00265     glLoadIdentity();
00266         glBindTexture(  GL_TEXTURE_2D, iCloudTexture.iID );
00267 
00268         glVertexPointer( 3, GL_FLOAT, 0, iCloudVertices );
00269         glTexCoordPointer( 2, GL_FLOAT, 0, iCloudTextureCoords );
00270     glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, cloudTriangles );
00271         }

00413         { 
00414         return iRainfall; 
00415         }

00400         {
00401         TTime time;
00402         time.UniversalTime();
00403         
00404         return time;
00405         }

00423         { 
00424         return iElapsedTime; 
00425         }

00433         { 
00434         return iFPSCount; 
00435         }

00443     {
00444     iScreenWidth  = aWidth;
00445     iScreenHeight = aHeight;
00446     
00447     // Notify the texture manager of screen size change
00448     iTextureManager->SetScreenSize( aWidth, aHeight );
00449 
00450     // Reinitialize viewport and projection.
00451     glViewport( 0, 0, iScreenWidth, iScreenHeight );
00452     
00453     // Recalculate the view frustrum
00454     glMatrixMode( GL_PROJECTION );
00455     glLoadIdentity();
00456     GLfloat aspectRatio = (GLfloat)(iScreenWidth) / (GLfloat)(iScreenHeight);
00457     glFrustumf( FRUSTUM_LEFT * aspectRatio, FRUSTUM_RIGHT * aspectRatio,
00458                 FRUSTUM_BOTTOM, FRUSTUM_TOP,
00459                 FRUSTUM_NEAR, FRUSTUM_FAR );
00460     glMatrixMode( GL_MODELVIEW );
00461 
00462     // Recalculate cloud vertices based on the aspect ratio
00463     iCloudVertices[ 0 ] = FRUSTUM_RIGHT * aspectRatio;
00464     iCloudVertices[ 1 ] = 0.f;
00465     iCloudVertices[ 2 ] = -FRUSTUM_NEAR;
00466 
00467     iCloudVertices[ 3 ] = FRUSTUM_RIGHT * aspectRatio;
00468     iCloudVertices[ 4 ] = FRUSTUM_TOP;
00469     iCloudVertices[ 5 ] = -FRUSTUM_NEAR;
00470 
00471     iCloudVertices[ 6 ] = FRUSTUM_LEFT * aspectRatio;
00472     iCloudVertices[ 7 ] = FRUSTUM_TOP;
00473     iCloudVertices[ 8 ] = -FRUSTUM_NEAR;
00474 
00475     iCloudVertices[ 9 ] = FRUSTUM_LEFT * aspectRatio;
00476     iCloudVertices[ 10 ] = 0.f;
00477     iCloudVertices[ 11 ] = -FRUSTUM_NEAR;
00478     }


Public Types
enum	{ ELoadingTextures, ERunning }
Public Member Functions
virtual	~CRain ()
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 ()
CRainfall *	GetRainfall ()
TTime	GetTimeTick ()
GLfloat	GetElapsedTime ()
GLfloat	GetFPSCount ()
void	SetScreenSize (TUint aWidth, TUint aHeight)
Static Public Member Functions
static CRain *	NewL (TUint aWidth, TUint aHeight)
Protected Member Functions
	CRain (TUint aWidth, TUint aHeight)
void	ConstructL (void)
Private Attributes
CTextureManager *	iTextureManager
TUint	iScreenWidth
TUint	iScreenHeight
TTexture	iTreeTexture
TTexture	iGrassTexture
TTexture	iCloudTexture
GLfloat	iCloudTextureCoords [8]
GLfloat	iTextureOffset
CRainfall *	iRainfall
TCamera	iCamera
TTime	iT0
TTime	iT1
GLfloat	iElapsedTime
GLfloat	iFPSCount
GLfloat	iCloudVertices [12]

CRain 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