Nokia N97 SDK
Example Applications Guide

Snow.cpp

00001 /*
00002  * ==============================================================================
00003  *  Name        : Snow.cpp
00004  *  Part of     : OpenGLEx / Snow
00005  *
00006  *  Copyright (c) 2004-2006 Nokia Corporation.
00007  *  This material, including documentation and any related
00008  *  computer programs, is protected by copyright controlled by
00009  *  Nokia Corporation.
00010  * ==============================================================================
00011  */
00012 
00013 // INCLUDE FILES
00014 
00015 #include "snow.h"
00016 #include <aknnotewrappers.h>
00017 #include <e32math.h>
00018 
00019 // MACROS
00020 
00021 // CONSTANTS
00022 
00023 /** Vertice coordinates for the ground plane. */
00024 static const GLbyte planeVertices[4 * 3] =
00025         {
00026     +1,0,-1,
00027     +1,0,+1,
00028     -1,0,+1,
00029     -1,0,-1
00030         };
00031 
00032 /** Texture coordinates for ground plane. */
00033 static const GLbyte planeTextureCoords[4 * 2] =
00034         {
00035       0, 10,
00036       0,  0,
00037      10,  0,
00038      10, 10
00039         };
00040 
00041 
00042 /** Indices for drawing the triangles of the ground plane. */
00043 static const GLubyte planeTriangles[2 * 3] =
00044         {
00045     0,2,1,
00046     0,3,2
00047         };
00048 
00049 
00050 /** Vertice coordinates for tree. */
00051 static const GLbyte treeVertices[4 * 3] =
00052         {
00053     +1, 0,0,
00054     +1,+1,0,
00055     -1,+1,0,
00056     -1, 0,0
00057         };
00058 
00059 /** Texture coordinates for tree. */
00060 static const GLbyte treeTextureCoords[4 * 2] =
00061         {
00062     0, 1,
00063     0, 0,
00064     1, 0,
00065     1, 1
00066         };
00067 
00068 /** Indices for drawing the tree. */
00069 static const GLubyte treeTriangles[2 * 3] =
00070         {
00071     0,1,2,
00072     0,2,3
00073         };
00074 
00075 /** Indices for drawing the clouds. */
00076 static const GLubyte cloudTriangles [] =
00077         {
00078     0,1,2,
00079     0,2,3
00080         };
00081 
00082 /** Vertice coordinates for snow. */
00083 static const GLbyte snowVertices[4 * 3] =
00084         {
00085     +2, 0,0,
00086     +2,+2,0,
00087     -2,+2,0,
00088     -2, 0,0
00089         };
00090 
00091 /** Texture coordinates for snow. */
00092 static const GLbyte snowTextureCoords[4 * 2] =
00093         {
00094     0, 1,
00095     0, 0,
00096     1, 0,
00097     1, 1
00098         };
00099 
00100 /* Indices for drawing the snow. */
00101 static const GLubyte snowTriangles[2 * 3] =
00102         {
00103     0,1,2,
00104     0,2,3
00105         };
00106 
00107 
00108 // LOCAL CONSTANTS AND MACROS
00109 
00110 // ============================= MEMBER FUNCTIONS ===============================
00111 
00112 // -----------------------------------------------------------------------------
00113 // CSnow::NewL
00114 // Symbian 2-phase constructor. Can leave.
00115 // -----------------------------------------------------------------------------
00116 //
00117 CSnow* CSnow::NewL( TUint aWidth, TUint aHeight )
00118         {
00119     /* Symbian 2-phase constructor. Calls both the default
00120        C++ constructor and Symbian ConstructL methods */
00121     CSnow* self = new (ELeave) CSnow( aWidth, aHeight );
00122     CleanupStack::PushL( self );
00123     self->ConstructL();
00124     CleanupStack::Pop();
00125 
00126     return self;
00127         }
00128 
00129 // Destructor.
00130 CSnow::~CSnow()
00131         {
00132         }
00133 
00134 // -----------------------------------------------------------------------------
00135 // CSnow::GetSnowfall
00136 // Gets the particle engine.
00137 // Returns:             The owned particle engine pointer
00138 // -----------------------------------------------------------------------------
00139 //
00140 CSnowfall* CSnow::GetSnowfall()
00141         {
00142         return iSnowfall;
00143         }
00144 
00145 // -----------------------------------------------------------------------------
00146 // CSnow::AppInit
00147 // Application initialization code.
00148 // -----------------------------------------------------------------------------
00149 //
00150 void CSnow::AppInitL( void )
00151         {
00152     // Construct a texture manager that uses the application's private
00153     // directory as the source location for all textures.
00154     iTextureManager = CTextureManager::NewL ( iScreenWidth, iScreenHeight,
00155                                               FRUSTUM_TOP, FRUSTUM_BOTTOM, FRUSTUM_RIGHT, FRUSTUM_LEFT, FRUSTUM_NEAR,
00156                                               this );
00157 
00158     // Initialize viewport and projection.
00159                 SetScreenSize( iScreenWidth, iScreenHeight );
00160 
00161     /* Set the screen background color. */
00162     glClearColor( 0.f, 0.f, 0.f, 1.f );
00163 
00164     /* Enable back face culling. */
00165     glEnable( GL_CULL_FACE  );
00166     glEnable( GL_TEXTURE_2D );
00167     glEnable( GL_DEPTH_TEST );
00168 
00169     //Enable alpha test for color keying.
00170     glEnable( GL_ALPHA_TEST );
00171     glAlphaFunc( GL_GREATER, 0.0f );
00172 
00173     /*Disable lighting */
00174     glDisable( GL_LIGHTING );
00175 
00176     // Calculate cloud vertices based on the aspect ratio
00177     GLfloat aspectRatio = (GLfloat)(iScreenWidth) / (GLfloat)(iScreenHeight);
00178     iCloudVertices[ 0 ] = FRUSTUM_RIGHT * aspectRatio;
00179     iCloudVertices[ 1 ] = 0.f;
00180     iCloudVertices[ 2 ] = -FRUSTUM_NEAR;
00181 
00182     iCloudVertices[ 3 ] = FRUSTUM_RIGHT * aspectRatio;
00183     iCloudVertices[ 4 ] = FRUSTUM_TOP;
00184     iCloudVertices[ 5 ] = -FRUSTUM_NEAR;
00185 
00186     iCloudVertices[ 6 ] = FRUSTUM_LEFT * aspectRatio;
00187     iCloudVertices[ 7 ] = FRUSTUM_TOP;
00188     iCloudVertices[ 8 ] = -FRUSTUM_NEAR;
00189 
00190     iCloudVertices[ 9 ] = FRUSTUM_LEFT * aspectRatio;
00191     iCloudVertices[ 10 ] = 0.f;
00192     iCloudVertices[ 11 ] = -FRUSTUM_NEAR;
00193 
00194     glMatrixMode( GL_MODELVIEW );
00195 
00196     /* Enable vertex arrays. */
00197     glEnableClientState( GL_VERTEX_ARRAY );
00198     /* Enable texture arrays. */
00199     glEnableClientState( GL_TEXTURE_COORD_ARRAY );
00200 
00201     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00202     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00203 
00204     glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
00205 
00206     iCloudTextureCoords[0] = 0; iCloudTextureCoords[1] = 1;
00207     iCloudTextureCoords[2] = 0; iCloudTextureCoords[3] = 0;
00208     iCloudTextureCoords[4] = 1; iCloudTextureCoords[5] = 0;
00209     iCloudTextureCoords[6] = 1; iCloudTextureCoords[7] = 1;
00210 
00211     iCamera.LookAt( TVector( 0, 30.0f, 0 ),
00212                     TVector(0, 0, -(FRUSTUM_FAR+FRUSTUM_NEAR)/2),
00213                     TVector(0, 1, 0));
00214 
00215     iSnowfall = CSnowfall::NewL(
00216         700,                                                       // Number of particles
00217         TVector( 0, 80, -( FRUSTUM_FAR + FRUSTUM_NEAR ) / 2 ),     // Center position
00218         120.f,                                                     // Area width
00219         ( FRUSTUM_FAR - FRUSTUM_NEAR ),                            // Area height
00220         0,                                                         // Ground level
00221         iTextureManager );                                         // Texture manager
00222 
00223     // Defining a color key interval for the tree texture.
00224     TUint8 MinColor[] = { 50, 0, 50 };
00225     TUint8 MaxColor[] = { 255, 75, 255 };
00226 
00227     // Pushing the textures into the loading queue.
00228         _LIT(KSnowyTreeName, "snowy_tree.gif");
00229         _LIT(KSnowyGroundName, "snowy_ground.jpg");
00230         _LIT(KCloudName, "cloud.jpg");
00231     iTextureManager->RequestToLoad(KSnowyTreeName, &iTreeTexture, MinColor, MaxColor );
00232     iTextureManager->RequestToLoad(KSnowyGroundName, &iGroundTexture );
00233     iTextureManager->RequestToLoad(KCloudName, &iCloudTexture );
00234 
00235     //Start to load the textures.
00236     iTextureManager->DoLoadL();
00237         }
00238 
00239 // -----------------------------------------------------------------------------
00240 // CSnow::AppExit
00241 // Application cleanup code.
00242 // -----------------------------------------------------------------------------
00243 //
00244 void CSnow::AppExit( void )
00245         {
00246     delete iSnowfall;
00247     delete iTextureManager;
00248         }
00249 
00250 // -----------------------------------------------------------------------------
00251 // CSnow::DrawPlane
00252 // Draws the ground plane.
00253 // -----------------------------------------------------------------------------
00254 //
00255 void CSnow::DrawPlane()
00256         {
00257     glBindTexture(  GL_TEXTURE_2D, iGroundTexture.iID );
00258     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_NEAREST);
00259     glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_NEAREST);
00260 
00261     glLoadIdentity();
00262     T3DModel::MakeWorldViewMatrix(iCamera, TVector(0.0f, 0.0f, 0.0f));
00263     glScalef( 1000, 0, 1000 );
00264 
00265 
00266     glVertexPointer( 3, GL_BYTE, 0, planeVertices );
00267     glTexCoordPointer( 2, GL_BYTE, 0, planeTextureCoords );
00268     glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, planeTriangles );
00269         }
00270 
00271 // -----------------------------------------------------------------------------
00272 // CSnow::DrawCloud
00273 // Draws the clouds.
00274 // -----------------------------------------------------------------------------
00275 //
00276 void CSnow::DrawCloud(GLfloat aDeltaTimeSecs )
00277         {
00278     iTextureOffset += (GLfloat)(0.01f*aDeltaTimeSecs);
00279 
00280     iCloudTextureCoords[0] = iCloudTextureCoords[2] = iTextureOffset;
00281     iCloudTextureCoords[4] = iCloudTextureCoords[6] = iTextureOffset + 0.4f;
00282 
00283     glDisable( GL_DEPTH_TEST );
00284 
00285     glLoadIdentity();
00286 
00287     glBindTexture(  GL_TEXTURE_2D, iCloudTexture.iID );
00288     glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
00289     glTexParameterf( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_NEAREST );
00290     glVertexPointer( 3, GL_FLOAT, 0, iCloudVertices );
00291     glTexCoordPointer( 2, GL_FLOAT, 0, iCloudTextureCoords );
00292     glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, cloudTriangles );
00293 
00294     glEnable( GL_DEPTH_TEST );
00295         }
00296 
00297 // -----------------------------------------------------------------------------
00298 // CSnow::DrawTree
00299 // Draws a tree.
00300 // -----------------------------------------------------------------------------
00301 //
00302 void CSnow::DrawTree( GLfloat aX, GLfloat aZ)
00303         {
00304     glLoadIdentity();
00305 
00306     //Turns the tree so that it always faces the camera.
00307     T3DModel::MakeBillboardWorldViewMatrix(iCamera, TVector(aX, 0.0f, aZ));
00308     glScalef( 10, 30, 10 );
00309 
00310     glBindTexture(  GL_TEXTURE_2D, iTreeTexture.iID );
00311     glTexParameterf( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_NEAREST );
00312     glTexParameterf( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_NEAREST );
00313 
00314     glVertexPointer( 3, GL_BYTE, 0, treeVertices );
00315     glTexCoordPointer( 2, GL_BYTE, 0, treeTextureCoords );
00316     glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, treeTriangles );
00317         }
00318 
00319 // ----------------------------------------------------------------------------
00320 // C#Name#::AppCycle
00321 // Draws and animates the objects.
00322 // aFrame = Number of the frame to be rendered.
00323 // aTimeSecs = Seconds elapsed since the application started running.
00324 // aDeltaTimeSecs = Seconds elapsed since last call to AppCycle().
00325 // ----------------------------------------------------------------------------
00326 //
00327 void CSnow::AppCycle( GLuint /*aFrame*/, GLfloat /*aTimeSecs*/, GLfloat aDeltaTimeSecs )
00328         {
00329     glClear( GL_DEPTH_BUFFER_BIT );
00330 
00331     /* Draws the clouds, and the ground plane */
00332     glDisable( GL_DEPTH_TEST );
00333     DrawCloud( aDeltaTimeSecs );
00334     DrawPlane();
00335 
00336     const TReal32 treeStepX = 30.0f;
00337     const TReal32 treeStepZ = 100.0f;
00338 
00339     //Draw the trees.
00340     DrawTree( -treeStepX, -1*treeStepZ);
00341     DrawTree( +treeStepX, -1*treeStepZ);
00342     DrawTree( -treeStepX, -2*treeStepZ);
00343     DrawTree( +treeStepX, -2*treeStepZ);
00344 
00345     glEnable( GL_DEPTH_TEST );
00346 
00347     /*Update and render the particle engine */
00348     iSnowfall->UpdateEngine( aDeltaTimeSecs );
00349     iSnowfall->RenderEngine( iCamera );
00350         }
00351 
00352 // ----------------------------------------------------------------------
00353 // CSnow::CSnow
00354 // C++ default constructor can NOT contain any code, that
00355 // might leave.
00356 // ----------------------------------------------------------------------
00357 //
00358 CSnow::CSnow( TUint aWidth, TUint aHeight )
00359         : CFiniteStateMachine()
00360         {
00361     iScreenWidth  = aWidth;
00362     iScreenHeight = aHeight;
00363 
00364         }
00365 
00366 // ----------------------------------------------------------------------
00367 // CSnow::ConstructL
00368 // Symbian 2nd phase constructor can leave.
00369 // ----------------------------------------------------------------------
00370 //
00371 void CSnow::ConstructL( void )
00372         {
00373         }
00374 
00375 // ---------------------------------------------------------
00376 // CSnow::OnEnterState( TInt aState )
00377 // Called by TFiniteStateMachine when the f.s.m enters a new state
00378 // ---------------------------------------------------------
00379 void CSnow::OnEnterStateL( TInt /*aState*/ )
00380         {
00381         }
00382 
00383 // -------------------------------------------------------------------------------------------------------
00384 // CSnow::OnStartLoadingTextures()
00385 // Called for a MTextureLoadingListener by the texture manager when texture loading operation starts
00386 // -------------------------------------------------------------------------------------------------------
00387 
00388 void CSnow::OnStartLoadingTexturesL()
00389         {
00390     SetStateL( ELoadingTextures );
00391         }
00392 
00393 // ------------------------------------------------------------------------------------------------------------
00394 // CSnow::OnEndLoadingTextures()
00395 // Called for a MTextureLoadingListener by the texture manager when texture loading operation is completed
00396 // ------------------------------------------------------------------------------------------------------------
00397 void CSnow::OnEndLoadingTexturesL()
00398         {
00399         if ( GetState() == ELoadingTextures )
00400                 {
00401         SetStateL( ERunning );
00402                 }
00403         }
00404 
00405 // -----------------------------------------------------------------------------
00406 // CSnow::SetScreenSize
00407 // Reacts to the dynamic screen size change during execution of this program.
00408 // -----------------------------------------------------------------------------
00409 //
00410 void CSnow::SetScreenSize( TUint aWidth, TUint aHeight )
00411     {
00412     iScreenWidth  = aWidth;
00413     iScreenHeight = aHeight;
00414 
00415     // Notify the texture manager of screen size change
00416     iTextureManager->SetScreenSize( aWidth, aHeight );
00417 
00418     // Reinitialize viewport and projection.
00419     glViewport( 0, 0, iScreenWidth, iScreenHeight );
00420 
00421     // Recalculate the view frustrum
00422     glMatrixMode( GL_PROJECTION );
00423     glLoadIdentity();
00424     GLfloat aspectRatio = (GLfloat)(iScreenWidth) / (GLfloat)(iScreenHeight);
00425     glFrustumf( FRUSTUM_LEFT * aspectRatio, FRUSTUM_RIGHT * aspectRatio,
00426                 FRUSTUM_BOTTOM, FRUSTUM_TOP,
00427                 FRUSTUM_NEAR, FRUSTUM_FAR );
00428     glMatrixMode( GL_MODELVIEW );
00429 
00430     // Recalculate cloud vertices based on the aspect ratio
00431     iCloudVertices[ 0 ] = FRUSTUM_RIGHT * aspectRatio;
00432     iCloudVertices[ 1 ] = 0.f;
00433     iCloudVertices[ 2 ] = -FRUSTUM_NEAR;
00434 
00435     iCloudVertices[ 3 ] = FRUSTUM_RIGHT * aspectRatio;
00436     iCloudVertices[ 4 ] = FRUSTUM_TOP;
00437     iCloudVertices[ 5 ] = -FRUSTUM_NEAR;
00438 
00439     iCloudVertices[ 6 ] = FRUSTUM_LEFT * aspectRatio;
00440     iCloudVertices[ 7 ] = FRUSTUM_TOP;
00441     iCloudVertices[ 8 ] = -FRUSTUM_NEAR;
00442 
00443     iCloudVertices[ 9 ] = FRUSTUM_LEFT * aspectRatio;
00444     iCloudVertices[ 10 ] = 0.f;
00445     iCloudVertices[ 11 ] = -FRUSTUM_NEAR;
00446     }
00447 
00448 // ----------------------------------------------------------------------
00449 // CSnowfall::CSnowfall
00450 // C++ default constructor can NOT contain any code, that
00451 // ----------------------------------------------------------------------
00452 //
00453 CSnowfall::CSnowfall()
00454         {
00455         };
00456 
00457 
00458 // ----------------------------------------------------------------------
00459 // CSnowfall::NewL
00460 // 2nd Two-phased constructor.
00461 // Creates and initializes a CSnowfall object:
00462 //   snowflakes are released from within
00463 //   the rectangle (aPosition.iX-aWidth/2, aPosition.iY, aPosition.iX-aWidth/2)
00464 //                 (aPosition.iX+aWidth/2, aPosition.iY, aPosition.iX+aWidth/2).
00465 //   Once their height is < iGroundLevel, they are reset.// Returns:    The current time.
00466 // ----------------------------------------------------------------------
00467 //
00468 
00469 CSnowfall* CSnowfall::NewL(GLint aParticlesCount, TVector aPosition,
00470                            GLfloat aWidth, GLfloat aDepth, GLfloat aGroundLevel,
00471                            CTextureManager * aTextureManager)
00472         {
00473     /* Symbian 2-phase constructor. Calls both the default
00474        C++ constructor and Symbian ConstructL methods */
00475     CSnowfall* self = new (ELeave) CSnowfall;
00476     CleanupStack::PushL( self );
00477     self->ConstructL( aParticlesCount, aPosition, aWidth, aDepth, aGroundLevel, aTextureManager);
00478     CleanupStack::Pop();
00479 
00480     return self;
00481         }
00482 
00483 // ----------------------------------------------------------------------
00484 // CSnowfall::ConstructL
00485 // 2nd phase constructor
00486 // Initializes a CSnowfall object:
00487 //   snowflakes are released from within
00488 //   the rectangle (aPosition.iX-aWidth/2, aPosition.iY, aPosition.iX-aWidth/2)
00489 //                 (aPosition.iX+aWidth/2, aPosition.iY, aPosition.iX+aWidth/2).
00490 //   Once their height is < iGroundLevel, they are reset.
00491 // ----------------------------------------------------------------------
00492 //
00493 void CSnowfall::ConstructL(GLint aParticlesCount, TVector aPosition,
00494                            GLfloat aWidth, GLfloat aDepth, GLfloat aGroundLevel,
00495                            CTextureManager * aTextureManager)
00496         {
00497     CParticleEngine::ConstructL(aParticlesCount, aPosition);
00498 
00499     iWidth = aWidth;
00500     iDepth = aDepth;
00501     iGroundLevel = aGroundLevel;
00502 
00503     TTime now;
00504     now.HomeTime();
00505     iSeed = now.Int64();
00506 
00507     ResetEngine();
00508 
00509         _LIT(KSnowName, "snow.jpg");
00510     aTextureManager->RequestToLoad(KSnowName, &iTexture );
00511         }
00512 
00513 // Destructor.
00514 
00515 CSnowfall::~CSnowfall()
00516         {
00517         }
00518 
00519 // ----------------------------------------------------------------------
00520 // CSnowfall::ResetParticle
00521 // Implementation of CParticleEngine::ResetParticle(GLint)
00522 // ----------------------------------------------------------------------
00523 //
00524 void CSnowfall::ResetParticle(GLint aIndex)
00525         {
00526     TParticle& Particle = iParticles[aIndex];
00527 
00528     Particle.iPosition = TVector(
00529         randrange( -iWidth / 0.5f, iWidth / 0.5f, iSeed ),
00530                 0,
00531                 randrange( -iDepth / 0.5f, iDepth / 0.5f, iSeed ) ) + iPosition;
00532 
00533     Particle.iVelocity = TVector(
00534         randrange( -0.2f,   0.2f, iSeed ),
00535         randrange( -20.f, -10.f, iSeed ),
00536         randrange( -0.2f,   0.2f, iSeed ) );
00537         }
00538 
00539 // ----------------------------------------------------------------------
00540 // CSnowfall::UpdateEngine
00541 // Implementation of CParticleEngine::UpdateEngine(GLfloat aElapsedTime)
00542 // ----------------------------------------------------------------------
00543 //
00544 void CSnowfall::UpdateEngine(GLfloat aDeltaTimeSecs)
00545         {
00546     for ( GLint i = 0; i < iParticlesCount; i++ )
00547                 {
00548         iParticles[i].iPosition += (iParticles[i].iVelocity * aDeltaTimeSecs);
00549         if ( iParticles[i].iPosition.iY < iGroundLevel )
00550                         {
00551             ResetParticle(i);
00552                         }
00553                 }
00554         }
00555 
00556 // ----------------------------------------------------------------------
00557 // CSnowfall::RenderEngine
00558 // Implementation of CParticleEngine::RenderEngine(TCamera &)
00559 // ----------------------------------------------------------------------
00560 //
00561 void CSnowfall::RenderEngine(TCamera& aCamera)
00562         {
00563     glEnable(GL_BLEND);
00564     glBlendFunc(GL_ONE, GL_ONE);
00565 
00566     TVector CameraPos = aCamera.GetPosition();
00567 
00568     glBindTexture(  GL_TEXTURE_2D, iTexture.iID );
00569     glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
00570     glVertexPointer( 3, GL_BYTE, 0, snowVertices );
00571     glTexCoordPointer( 2, GL_BYTE, 0, snowTextureCoords );
00572 
00573     for ( GLint i = 0; i < iParticlesCount; i++ )
00574                 {
00575         glLoadIdentity();
00576         glTranslatef(iParticles[i].iPosition.iX-CameraPos.iX,
00577                      iParticles[i].iPosition.iY-CameraPos.iY,
00578                      iParticles[i].iPosition.iZ-CameraPos.iZ);
00579 
00580         glDrawElements( GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, snowTriangles );
00581                 }
00582 
00583     glDisable(GL_BLEND);
00584         }
00585 
00586 

© Nokia 2009

Back to top