|
Nokia N97 SDK Example Applications Guide |
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 |