/*!**************************************************************************** @Function InitView @Return bool true if no error occured @Description Code in InitView() will be called by PVRShell upon initialization or after a change in the rendering context. Used to initialize variables that are dependant on the rendering context (e.g. textures, vertex buffers, etc.) ******************************************************************************/ bool OGLESEvilSkull::InitView() { PVRTMat4 mPerspective; SPVRTContext sContext; // Initialize Print3D textures bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen); if(m_Print3D.SetTextures(&sContext, PVRShellGet(prefWidth), PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n"); return false; } /*********************** ** LOAD TEXTURES ** ***********************/ if(PVRTTextureLoadFromPVR(c_szIrisTexFile, &m_ui32Texture[0]) != PVR_SUCCESS) return false; myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); if(PVRTTextureLoadFromPVR(c_szMetalTexFile, &m_ui32Texture[1]) != PVR_SUCCESS) return false; myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); if(PVRTTextureLoadFromPVR(c_szFire02TexFile, &m_ui32Texture[2]) != PVR_SUCCESS) return false; myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); if(PVRTTextureLoadFromPVR(c_szFire03TexFile, &m_ui32Texture[3]) != PVR_SUCCESS) return false; myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); /****************************** ** GENERIC RENDER STATES ** *******************************/ // The Type Of Depth Test To Do glDepthFunc(GL_LEQUAL); // Enables Depth Testing glEnable(GL_DEPTH_TEST); // Enables Smooth Color Shading glShadeModel(GL_SMOOTH); // Blending mode glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Culling glEnable(GL_CULL_FACE); glCullFace(GL_BACK); // Create perspective matrix mPerspective = PVRTMat4::PerspectiveFovRH(f2vt(70.0f*(3.14f/180.0f)), f2vt((float)PVRShellGet(prefWidth) /(float)PVRShellGet(prefHeight) ), f2vt(10.0f), f2vt(10000.0f), PVRTMat4::OGL, bRotate); glMatrixMode(GL_PROJECTION); myglLoadMatrix(mPerspective.f); // Create viewing matrix m_mView = PVRTMat4::LookAtRH(m_CameraPos, m_CameraTo, m_CameraUp); glMatrixMode(GL_MODELVIEW); myglLoadMatrix(m_mView.f); // Enable texturing glEnable(GL_TEXTURE_2D); // Lights (only one side lighting) glEnable(GL_LIGHTING); // Light 0 (White directional light) PVRTVec4 fAmbient = PVRTVec4(f2vt(0.2f), f2vt(0.2f), f2vt(0.2f), f2vt(1.0f)); PVRTVec4 fDiffuse = PVRTVec4(f2vt(1.0f), f2vt(1.0f), f2vt(1.0f), f2vt(1.0f)); PVRTVec4 fSpecular = PVRTVec4(f2vt(1.0f), f2vt(1.0f), f2vt(1.0f), f2vt(1.0f)); myglLightv(GL_LIGHT0, GL_AMBIENT, fAmbient.ptr()); myglLightv(GL_LIGHT0, GL_DIFFUSE, fDiffuse.ptr()); myglLightv(GL_LIGHT0, GL_SPECULAR, fSpecular.ptr()); myglLightv(GL_LIGHT0, GL_POSITION, m_LightPos.ptr()); glEnable(GL_LIGHT0); glDisable(GL_LIGHTING); // Create the data used for the morphing CreateMorphData(); // Sets the clear color myglClearColor(f2vt(0.0f), f2vt(0.0f), f2vt(0.0f), f2vt(1.0f)); // Create vertex buffer objects LoadVbos(); return true; }
/*!**************************************************************************** @Function InitView @Return bool true if no error occured @Description Code in InitView() will be called by PVRShell upon initialization or after a change in the rendering context. Used to initialize variables that are dependant on the rendering context (e.g. textures, vertex buffers, etc.) ******************************************************************************/ bool OGLESParticles::InitView() { PVRTMat4 mProjection; SPVRTContext sContext; bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen); // Initialize Print3D textures if(m_Print3D.SetTextures(&sContext, PVRShellGet(prefWidth), PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D.\n"); return false; } // Initialize Extensions m_Extensions.LoadExtensions(); // Load textures. if(PVRTTextureLoadFromPVR(c_szLightTexFile, &m_ui32TexName) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Cannot load light texture.\n"); return false; } myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); if(PVRTTextureLoadFromPVR(c_szFloorTexFile, &m_ui32FloorTexName) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Cannot load floor texture.\n"); return false; } myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); myglTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glMatrixMode(GL_PROJECTION); glLoadIdentity(); if(bRotate) myglRotate(f2vt(90), f2vt(0), f2vt(0), f2vt(1)); // Creates the projection matrix. mProjection = PVRTMat4::PerspectiveFovRH(f2vt(45.0f*(PVRT_PIf/180.0f)), f2vt((float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight)), f2vt(10.0f), f2vt(1200.0f), PVRTMat4::OGL); myglMultMatrix(mProjection.f); // Calculates the attenuation coefficient for the points drawn. double H = bRotate ? PVRShellGet(prefWidth) : PVRShellGet(prefHeight); double h = 2.0 / mProjection.f[5]; double D0 = sqrt(2.0) * H / h; double k = 1.0/(1.0 + 2.0 * (1 / mProjection.f[5]) * (1 / mProjection.f[5])); m_fPointAttenuationCoef = (float)(1.0 / (D0 * D0) * k); // Creates the model view matrix. m_mView = PVRTMat4::LookAtRH(m_fFrom, m_fTo, g_fUp); glMatrixMode(GL_MODELVIEW); myglLoadMatrix(m_mView.f); /* Pre-Set TexCoords since they never change. Pre-Set the Index Buffer. */ for(unsigned int i = 0; i < g_ui32MaxParticles; ++i) { m_sParticleVTXBuf[i*4+0].u = 0; m_sParticleVTXBuf[i*4+0].v = 0; m_sParticleVTXBuf[i*4+1].u = 1; m_sParticleVTXBuf[i*4+1].v = 0; m_sParticleVTXBuf[i*4+2].u = 0; m_sParticleVTXBuf[i*4+2].v = 1; m_sParticleVTXBuf[i*4+3].u = 1; m_sParticleVTXBuf[i*4+3].v = 1; m_ui16ParticleINDXBuf[i*6+0] = (i*4) + 0; m_ui16ParticleINDXBuf[i*6+1] = (i*4) + 1; m_ui16ParticleINDXBuf[i*6+2] = (i*4) + 2; m_ui16ParticleINDXBuf[i*6+3] = (i*4) + 2; m_ui16ParticleINDXBuf[i*6+4] = (i*4) + 1; m_ui16ParticleINDXBuf[i*6+5] = (i*4) + 3; } // Create vertex buffers. glGenBuffers(1, &m_i32VertVboID); glGenBuffers(1, &m_i32ColAVboID); glGenBuffers(1, &m_i32ColBVboID); glGenBuffers(1, &m_i32QuadVboID); // Preset the floor uvs and vertices as they never change. PVRTVec3 pos(0, 0, 0); float szby2 = 100; m_sQuadVTXBuf[0].x = m_fFloorQuadVerts[0] = pos.x - f2vt(szby2); m_sQuadVTXBuf[0].y = m_fFloorQuadVerts[1] = pos.y; m_sQuadVTXBuf[0].z = m_fFloorQuadVerts[2] = pos.z - f2vt(szby2); m_sQuadVTXBuf[1].x = m_fFloorQuadVerts[3] = pos.x + f2vt(szby2); m_sQuadVTXBuf[1].y = m_fFloorQuadVerts[4] = pos.y; m_sQuadVTXBuf[1].z = m_fFloorQuadVerts[5] = pos.z - f2vt(szby2); m_sQuadVTXBuf[2].x = m_fFloorQuadVerts[6] = pos.x - f2vt(szby2); m_sQuadVTXBuf[2].y = m_fFloorQuadVerts[7] = pos.y; m_sQuadVTXBuf[2].z = m_fFloorQuadVerts[8] = pos.z + f2vt(szby2); m_sQuadVTXBuf[3].x = m_fFloorQuadVerts[9] = pos.x + f2vt(szby2); m_sQuadVTXBuf[3].y = m_fFloorQuadVerts[10] = pos.y; m_sQuadVTXBuf[3].z = m_fFloorQuadVerts[11] = pos.z + f2vt(szby2); m_fFloorQuadUVs[0] = f2vt(0); m_fFloorQuadUVs[1] = f2vt(0); m_sQuadVTXBuf[0].u = 0; m_sQuadVTXBuf[0].v = 0; m_fFloorQuadUVs[2] = f2vt(1); m_fFloorQuadUVs[3] = f2vt(0); m_sQuadVTXBuf[1].u = 255; m_sQuadVTXBuf[1].v = 0; m_fFloorQuadUVs[4] = f2vt(0); m_fFloorQuadUVs[5] = f2vt(1); m_sQuadVTXBuf[2].u = 0; m_sQuadVTXBuf[2].v = 255; m_fFloorQuadUVs[6] = f2vt(1); m_fFloorQuadUVs[7] = f2vt(1); m_sQuadVTXBuf[3].u = 255; m_sQuadVTXBuf[3].v = 255; glBindBuffer(GL_ARRAY_BUFFER, m_i32QuadVboID); glBufferData(GL_ARRAY_BUFFER, sizeof(SVtx) * 4, m_sQuadVTXBuf, GL_STATIC_DRAW); return true; }
/******************************************************************************* * Function Name : InitView * Returns : true if no error occured * Description : Code in InitView() will be called by the Shell upon a change * in the rendering context. * Used to initialize variables that are dependant on the rendering * context (e.g. textures, vertex buffers, etc.) *******************************************************************************/ bool OGLESVase::InitView() { CPVRTString ErrorStr; SPVRTContext Context; // Is the screen rotated? bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen); // Initialize Print3D textures if(m_Print3D.SetTextures(&Context, PVRShellGet(prefWidth), PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n"); return false; } // Load textures if(!LoadTextures(&ErrorStr)) { PVRShellSet(prefExitMessage, ErrorStr.c_str()); return false; } // Initialize VBO data LoadVbos(); // Initialize Background if(m_Background.Init(0, bRotate) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Background\n"); return false; } /* Build an array to map the textures within the pod file to the textures we loaded earlier. */ m_pui32Textures = new GLuint[m_Scene.nNumMaterial]; for(unsigned int i = 0; i < m_Scene.nNumMaterial; ++i) { m_pui32Textures[i] = 0; SPODMaterial* pMaterial = &m_Scene.pMaterial[i]; if(!strcmp(pMaterial->pszName, "Flora")) m_pui32Textures[i] = m_uiFloraTex; else if(!strcmp(pMaterial->pszName, "Reflection")) m_pui32Textures[i] = m_uiReflectTex; } // Calculates the projection matrix m_mProjection = PVRTMat4::PerspectiveFovRH(f2vt(35.0f*(3.14f/180.0f)), f2vt((float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight)), f2vt(g_fCameraNear), f2vt(g_fCameraFar), PVRTMat4::OGL, bRotate); // Loads the projection matrix glMatrixMode(GL_PROJECTION); myglLoadMatrix(m_mProjection.f); // Enable texturing glEnable(GL_TEXTURE_2D); // Setup clear colour myglClearColor(f2vt(1.0f),f2vt(1.0f),f2vt(1.0f),f2vt(1.0f)); // Set blend mode glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); return true; }
/*!**************************************************************************** @Function RenderScene @Return bool true if no error occured @Description Main rendering loop function of the program. The shell will call this function every frame. eglSwapBuffers() will be performed by PVRShell automatically. PVRShell will also manage important OS events. Will also manage relevent OS events. The user has access to these events through an abstraction layer provided by PVRShell. ******************************************************************************/ bool OGLESFur::RenderScene() { // Reset the states that print3D changes glDisable(GL_CULL_FACE); glEnable(GL_FOG); glEnable(GL_LIGHT0); glEnable(GL_LIGHTING); glEnable(GL_DEPTH_TEST); // User input bool bNewPage = false; if(PVRShellIsKeyPressed(PVRShellKeyNameSELECT)) m_bPause = !m_bPause; if(PVRShellIsKeyPressed(PVRShellKeyNameLEFT)) { if(--m_i32WndPage < 0) m_i32WndPage = 5; bNewPage = true; } if(PVRShellIsKeyPressed(PVRShellKeyNameRIGHT)) { if(++m_i32WndPage > 5) m_i32WndPage = 0; bNewPage = true; } if(bNewPage) { switch(m_i32WndPage) { case 0: m_bViewMode = false; m_i32FurShellNo = 7; break; case 1: m_bViewMode = true; m_i32FurShellNo = 0; break; case 2: m_bViewMode = true; m_i32FurShellNo = 1; break; case 3: m_bViewMode = true; m_i32FurShellNo = 2; break; case 4: m_bViewMode = true; m_i32FurShellNo = 7; break; case 5: m_bViewMode = false; m_i32FurShellNo = 7; break; } // Since the number of fur shells has changed, update them UpdateFurShells(); } // Clear glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Animation DoAnimation(); // View matrix glMatrixMode(GL_MODELVIEW); myglLoadMatrix(m_mView.f); // Enable the vertex and normal arrays glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); // Begin Scene if(!m_bViewMode) DrawEnvironment(); // Draw the Duck DrawDuck(); // Display the information window if required if(m_bWndRender) m_Print3D.DisplayWindow(m_ui32WindowID[m_i32WndPage]); // Display Paused if the app is paused if(m_bPause) m_Print3D.Print3D(78.0f, 2.0f, 1.0f, PVRTRGBA(255,255,255,255), "Paused"); // Display the IMG logo m_Print3D.DisplayDefaultTitle(NULL, NULL, ePVRTPrint3DSDKLogo); m_Print3D.Flush(); return true; }
/*!**************************************************************************** @Function InitView @Return bool true if no error occured @Description Code in InitView() will be called by PVRShell upon initialization or after a change in the rendering context. Used to initialize variables that are dependant on the rendering context (e.g. textures, vertex buffers, etc.) ******************************************************************************/ bool OGLESFur::InitView() { // Setup the projection matrix glMatrixMode(GL_PROJECTION); bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen); m_mProj = PVRTMat4::PerspectiveFovRH(g_fFOV, f2vt((float)PVRShellGet(prefWidth) / (float)PVRShellGet(prefHeight)), g_fNear, g_fFar, PVRTMat4::OGL, bRotate); myglLoadMatrix(m_mProj.f); // Set clear colour myglClearColor(c_vFogColour.x, c_vFogColour.y, c_vFogColour.z, c_vFogColour.w); // Enable Smooth Color Shading glShadeModel(GL_SMOOTH); // Enable the depth buffer glEnable(GL_DEPTH_TEST); // Load fur data glGenBuffers(g_ui32MaxNoOfFurShells, m_uiShellVbo); UpdateFurShells(); // Initialise 3D text if(m_Print3D.SetTextures(NULL, PVRShellGet(prefWidth), PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS) return false; // Load textures CPVRTString ErrorStr; if(!LoadTextures(&ErrorStr)) { PVRShellSet(prefExitMessage, ErrorStr.c_str()); return false; } // Create VBOs if(!LoadVbos(&ErrorStr)) { PVRShellSet(prefExitMessage, ErrorStr.c_str()); return false; } // Initialise camera m_Scene.GetCameraPos(m_vCamFrom, m_vCamTo, 0); m_vCamFrom = PVRTVec3(f2vt(0.0f), f2vt(400.0f), f2vt(0.0f)); // Enable fog myglFog(GL_FOG_MODE, GL_EXP2); myglFog(GL_FOG_DENSITY, c_fFogDensity); myglFogv(GL_FOG_COLOR, &c_vFogColour.x); glEnable(GL_FOG); // Enable lighting myglLightv(GL_LIGHT0, GL_POSITION, &c_vLightPosition.x); myglLightv(GL_LIGHT0, GL_DIFFUSE, &c_vLightColour.x); myglLightv(GL_LIGHT0, GL_AMBIENT, &c_vLightAmbient.x); myglLightv(GL_LIGHT0, GL_SPECULAR, &c_vLightColour.x); glEnable(GL_LIGHT0); glEnable(GL_LIGHTING); // Disable culling glDisable(GL_CULL_FACE); // Initialise time m_ui32PrevTime = PVRShellGetTime(); return true; }
/******************************************************************************* * Function Name : RenderScene * Returns : true if no error occured * Description : Main rendering loop function of the program. The shell will * call this function every frame. *******************************************************************************/ bool OGLESOptimizeMesh::RenderScene() { unsigned long ui32Time; // Clear the depth and frame buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); #ifdef ENABLE_LOAD_TIME_STRIP /* Show a message on-screen then generate the necessary data on the second frame. */ if(m_i32Init) { --m_i32Init; if(m_i32Init) { m_Print3D.DisplayDefaultTitle("OptimizeMesh", "Generating data...", ePVRTPrint3DSDKLogo); m_Print3D.Flush(); return true; } StripMesh(); LoadVbos(); } #endif // Time ui32Time = PVRShellGetTime(); m_ui32TimeDiff = ui32Time - m_ui32LastTime; m_ui32LastTime = ui32Time; // FPS ++m_ui32FPSFrameCnt; m_ui32FPSTimeDiff += m_ui32TimeDiff; if(m_ui32FPSTimeDiff >= g_ui32TimeFPSUpdate) { m_fFPS = m_ui32FPSFrameCnt * 1000.0f / (float) m_ui32FPSTimeDiff; m_ui32FPSFrameCnt = 0; m_ui32FPSTimeDiff = 0; } // Change mode when necessary m_ui32SwitchTimeDiff += m_ui32TimeDiff; if((m_ui32SwitchTimeDiff > g_ui32TimeAutoSwitch)) // if((m_ui32SwitchTimeDiff > g_ui32TimeAutoSwitch) || PVRShellIsKeyPressed(PVRShellKeyNameACTION1)) { m_ui32SwitchTimeDiff = 0; ++m_i32Page; if(m_i32Page >= (int) m_ui32PageNo) m_i32Page = 0; } PVRTVec3 From; VERTTYPE fFactor; From.x = VERTTYPEMUL(g_fViewDistance, PVRTCOS(m_fViewAngle)); From.y = f2vt(0.0f); From.z = VERTTYPEMUL(g_fViewDistance, PVRTSIN(m_fViewAngle)); // Increase the rotation fFactor = f2vt(0.005f * (float) m_ui32TimeDiff); m_fViewAngle += fFactor; // Ensure it doesn't grow huge and lose accuracy over time if(m_fViewAngle > PVRT_PI) m_fViewAngle -= PVRT_TWO_PI; // Compute and set the matrix m_mView = PVRTMat4::LookAtRH(From, PVRTVec3(0,0,0), PVRTVec3(0,f2vt(1),0)); glMatrixMode(GL_MODELVIEW); myglLoadMatrix(m_mView.f); // Draw the model DrawModel(m_i32Page); // Display the frame rate char pTitle[512]; const char * pDesc; sprintf(pTitle, "Optimize Mesh %.1ffps", m_fFPS); // Print text on screen switch(m_i32Page) { default: pDesc = "Indexed Triangle List: Unoptimized"; break; case 1: pDesc = "Indexed Triangle List: Optimized (at export time)"; break; #ifdef ENABLE_LOAD_TIME_STRIP case 2: pDesc = "Indexed Triangle List: Optimized (at load time)"; break; #endif } m_Print3D.DisplayDefaultTitle(pTitle, pDesc, ePVRTPrint3DSDKLogo); // Flush all Print3D commands m_Print3D.Flush(); return true; }
/******************************************************************************* * Function Name : InitView * Inputs : * Returns : true if no error occured * Description : Code in InitView() will be called by the Shell upon a change * in the rendering context. * Used to initialize variables that are dependant on the rendering * context (e.g. textures, vertex buffers, etc.) *******************************************************************************/ bool OGLESOptimizeMesh::InitView() { SPVRTContext sContext; bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen); // Init Print3D to display text on screen if(m_Print3D.SetTextures(&sContext, PVRShellGet(prefWidth), PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D.\n"); return false; } /****************************** ** Create Textures ** *******************************/ if(PVRTTextureLoadFromPVR(c_szModelTexFile, &m_Texture) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Failed to load texture for model.\n"); return false; } /********************************* ** View and Projection Matrices ** *********************************/ // Get Camera info from POD file PVRTVec3 From, To; VERTTYPE fFOV; if(m_Model.nNumCamera) { // Get Camera data from POD Geometry File fFOV = m_Model.GetCameraPos(From, To, 0); fFOV = VERTTYPEMUL(fFOV, f2vt(0.75f)); // Convert from horizontal FOV to vertical FOV (0.75 assumes a 4:3 aspect ratio) } else { fFOV = f2vt(PVRT_PIf / 6); } // View m_mView = PVRTMat4::LookAtRH(From, To, PVRTVec3(f2vt(0.0f), f2vt(1.0f), f2vt(0.0f))); // Projection m_mProj = PVRTMat4::PerspectiveFovRH(fFOV, f2vt((float) PVRShellGet(prefWidth) / (float) PVRShellGet(prefHeight)), g_fCameraNear, g_fCameraFar, PVRTMat4::OGL, bRotate); glMatrixMode(GL_PROJECTION); myglLoadMatrix(m_mProj.f); /****************************** ** GENERIC RENDER STATES ** ******************************/ // The Type Of Depth Test To Do glDepthFunc(GL_LEQUAL); // Enables Depth Testing glEnable(GL_DEPTH_TEST); // Enables Smooth Color Shading glShadeModel(GL_SMOOTH); // Define front faces glFrontFace(GL_CW); // Sets the clear colour myglClearColor(f2vt(0.6f), f2vt(0.8f), f2vt(1.0f), f2vt(1.0f)); // Reset the model view matrix to position the light glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // Setup timing variables m_ui32LastTime = PVRShellGetTime(); m_ui32FPSFrameCnt = 0; m_fFPS = 0; m_fViewAngle = 0; m_ui32SwitchTimeDiff = 0; #ifndef ENABLE_LOAD_TIME_STRIP LoadVbos(); #endif return true; }