/*!****************************************************************************
@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;
}
