/*!****************************************************************************
@Function ReleaseView
@Return bool true if no error occured
@Description Code in ReleaseView() will be called by PVRShell when the
application quits or before a change in the rendering context.
******************************************************************************/
bool OGLESRenderToTexture::ReleaseView()
{
// Delete the texture
glDeleteTextures(1, &m_uiTextureID);
glDeleteTextures(1, &m_uiTextureToRenderTo);
// Release Print3D Textures
m_Print3D.ReleaseTextures();
// Destroy the FBO or PBuffer surface we were using
switch(m_eR2TType)
{
case eFBO:
// Delete frame buffer objects
m_Extensions.glDeleteFramebuffersOES(1, &m_uFBO);
// Delete our depth buffer
m_Extensions.glDeleteRenderbuffersOES(1, &m_uDepthBuffer);
break;
#if !defined(EGL_NOT_PRESENT)
case ePBuffer:
// Destroy the surfaces we created
eglDestroySurface(m_CurrentDisplay, m_PBufferSurface);
break;
#endif
default:
break;
}
return true;
}
/*******************************************************************************
* Function Name : DrawModel
* Description : Draws the model
*******************************************************************************/
void OGLESSkinning::DrawModel()
{
//Set the frame number
m_Scene.SetFrame(m_fFrame);
// Enable lighting
glEnable(GL_LIGHTING);
// Enable States
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//Iterate through all the mesh nodes in the scene
for(int iNode = 0; iNode < (int)m_Scene.nNumMeshNode; ++iNode)
{
//Get the mesh node.
SPODNode* pNode = &m_Scene.pNode[iNode];
//Get the mesh that the mesh node uses.
SPODMesh* pMesh = &m_Scene.pMesh[pNode->nIdx];
// bind the VBO for the mesh
glBindBuffer(GL_ARRAY_BUFFER, m_puiVbo[pNode->nIdx]);
// bind the index buffer, won't hurt if the handle is 0
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_puiIndexVbo[pNode->nIdx]);
// Loads the correct texture using our texture lookup table
if(pNode->nIdxMaterial == -1)
glBindTexture(GL_TEXTURE_2D, 0); // It has no pMaterial defined. Use blank texture (0)
else
glBindTexture(GL_TEXTURE_2D, m_puiTextures[pNode->nIdxMaterial]);
//If the mesh has bone weight data then we must be skinning.
bool bSkinning = pMesh->sBoneWeight.n != 0;
if(bSkinning)
{
//If we are skinning then enable the relevant states.
glEnableClientState(GL_MATRIX_INDEX_ARRAY_OES);
glEnableClientState(GL_WEIGHT_ARRAY_OES);
}
else
{
// If we're not using matrix palette then get the world matrix for the mesh
// and transform the model view matrix by it.
PVRTMat4 worldMatrix;
m_Scene.GetWorldMatrix(worldMatrix, *pNode);
//Push the modelview matrix
glPushMatrix();
glMultMatrixf(worldMatrix.f);
}
// Set Data Pointers
// Used to display non interleaved geometry
glVertexPointer(pMesh->sVertex.n, GL_FLOAT, pMesh->sVertex.nStride, pMesh->sVertex.pData);
glNormalPointer(GL_FLOAT, pMesh->sNormals.nStride, pMesh->sNormals.pData);
glTexCoordPointer(pMesh->psUVW[0].n, GL_FLOAT, pMesh->psUVW[0].nStride, pMesh->psUVW[0].pData);
if(bSkinning)
{
//Set up the indexes into the matrix palette.
m_Extensions.glMatrixIndexPointerOES(pMesh->sBoneIdx.n, GL_UNSIGNED_BYTE, pMesh->sBoneIdx.nStride, pMesh->sBoneIdx.pData);
m_Extensions.glWeightPointerOES(pMesh->sBoneWeight.n, GL_FLOAT, pMesh->sBoneWeight.nStride, pMesh->sBoneWeight.pData);
}
// Draw
/*
2 variables used by the indexed triangle-strip version of the drawing code that is included as an
example but is unused as the .pod file supplied contains indexed triangle-list data.
*/
int i32Strip = 0;
int i32Offset = 0;
/*
As we are using bone batching we don't want to draw all the faces contained within pMesh at once, we only
want to draw the ones that are in the current batch. To do this we loop through the batches and pass to the
the draw call the offser to the start of the current batch of triangles
(pMesh->sBoneBatches.pnBatchOffset[i32Batch]) and the total number of triangles to draw (i32Tris)
*/
for(int i32Batch = 0; i32Batch < (bSkinning ? pMesh->sBoneBatches.nBatchCnt : 1); ++i32Batch)
{
// If the mesh is used for skining then set up the matrix palettes.
if(bSkinning)
{
//Enable the matrix palette extension
glEnable(GL_MATRIX_PALETTE_OES);
/*
Enables the matrix palette stack extension, and apply subsequent
matrix operations to the matrix palette stack.
*/
glMatrixMode(GL_MATRIX_PALETTE_OES);
PVRTMat4 mBoneWorld;
int i32NodeID;
// Iterate through all the bones in the batch
for(int j = 0; j < pMesh->sBoneBatches.pnBatchBoneCnt[i32Batch]; ++j)
{
/*
Set the current matrix palette that we wish to change. An error
will be returned if the index (j) is not between 0 and
GL_MAX_PALETTE_MATRICES_OES. The value of GL_MAX_PALETTE_MATRICES_OES
can be retrieved using glGetIntegerv, the initial value is 9.
GL_MAX_PALETTE_MATRICES_OES does not mean you need to limit
your character to 9 bones as you can overcome this limitation
by using bone batching which splits the mesh up into sub-meshes
which use only a subset of the bones.
*/
m_Extensions.glCurrentPaletteMatrixOES(j);
// Generates the world matrix for the given bone in this batch.
i32NodeID = pMesh->sBoneBatches.pnBatches[i32Batch * pMesh->sBoneBatches.nBatchBoneMax + j];
m_Scene.GetBoneWorldMatrix(mBoneWorld, *pNode, m_Scene.pNode[i32NodeID]);
// Multiply the bone's world matrix by our transformation matrix and the view matrix
mBoneWorld = m_mView * m_mTransform * mBoneWorld;
// Load the bone matrix into the current palette matrix.
glLoadMatrixf(mBoneWorld.f);
}
}
else
{
//If we're not skinning then disable the matrix palette.
glDisable(GL_MATRIX_PALETTE_OES);
}
//Switch to the modelview matrix.
glMatrixMode(GL_MODELVIEW);
// Calculate the number of triangles in the current batch
int i32Tris;
if(bSkinning)
{
if(i32Batch + 1 < pMesh->sBoneBatches.nBatchCnt)
i32Tris = pMesh->sBoneBatches.pnBatchOffset[i32Batch+1] - pMesh->sBoneBatches.pnBatchOffset[i32Batch];
else
i32Tris = pMesh->nNumFaces - pMesh->sBoneBatches.pnBatchOffset[i32Batch];
}
else
i32Tris = pMesh->nNumFaces;
// Indexed Triangle list
if(pMesh->nNumStrips == 0)
{
size_t offset = bSkinning ? sizeof(GLushort) * 3 * pMesh->sBoneBatches.pnBatchOffset[i32Batch] : 0;
glDrawElements(GL_TRIANGLES, i32Tris * 3, GL_UNSIGNED_SHORT, (void*) offset);
}
else // Indexed Triangle strips
{
int i32TrisDrawn = 0;
while(i32TrisDrawn < i32Tris)
{
glDrawElements(GL_TRIANGLE_STRIP, pMesh->pnStripLength[i32Strip]+2, GL_UNSIGNED_SHORT, (void*) (i32Offset * sizeof(GLushort)));
i32Offset += pMesh->pnStripLength[i32Strip]+2;
i32TrisDrawn += pMesh->pnStripLength[i32Strip];
++i32Strip;
}
}
}
if(bSkinning)
{
glDisableClientState(GL_MATRIX_INDEX_ARRAY_OES);
glDisableClientState(GL_WEIGHT_ARRAY_OES);
// We are finished with the matrix pallete so disable it.
glDisable(GL_MATRIX_PALETTE_OES);
}
else
{
//Reset the modelview matrix back to what it was before we transformed by the mesh node.
glPopMatrix();
}
}
// Disable States
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// unbind the vertex buffers as we don't need them bound anymore
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
/*******************************************************************************
* 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 OGLESSkinning::InitView()
{
CPVRTString error;
// Check to see whether the matrix palette extension is supported.
if(!CPVRTglesExt::IsGLExtensionSupported("GL_OES_matrix_palette"))
{
PVRShellSet(prefExitMessage, "ERROR: The extension GL_OES_matrix_palette is unsupported.\n");
return false;
}
// Initialise the matrix palette extensions
m_Extensions.LoadExtensions();
// Load the textures
if(!LoadTextures(&error))
{
PVRShellSet(prefExitMessage, error.c_str());
return false;
}
// Init Print3D to display text on screen
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
if(m_Print3D.SetTextures(0, PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
// Model View Matrix
CameraGetMatrix();
// Projection Matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(m_mProjection.f);
// GENERIC RENDER STATES
// Enables Depth Testing
glEnable(GL_DEPTH_TEST);
// Enables Smooth Colour Shading
glShadeModel(GL_SMOOTH);
// Enable texturing
glEnable(GL_TEXTURE_2D);
// Define front faces
glFrontFace(GL_CW);
// Enables texture clamping
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
// Reset the model view matrix to position the light
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Setup ambiant light
glEnable(GL_LIGHTING);
PVRTVec4 lightGlobalAmbient = PVRTVec4(1.0f, 1.0f, 1.0f, 1.0f);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightGlobalAmbient.ptr());
// Setup a directional light source
PVRTVec4 lightPosition = PVRTVec4(-0.7f, -1.0f, 0.2f, 0.0f);
PVRTVec4 lightAmbient = PVRTVec4(1.0f, 1.0f, 1.0f, 1.0f);
PVRTVec4 lightDiffuse = PVRTVec4(1.0f, 1.0f, 1.0f, 1.0f);
PVRTVec4 lightSpecular = PVRTVec4(0.2f, 0.2f, 0.2f, 1.0f);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, lightPosition.ptr());
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient.ptr());
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse.ptr());
glLightfv(GL_LIGHT0, GL_SPECULAR, lightSpecular.ptr());
LoadVbos();
/*
Initialise an array to lookup the textures
for each material in the scene.
*/
m_puiTextures = new GLuint[m_Scene.nNumMaterial];
for(unsigned int i = 0; i < m_Scene.nNumMaterial; ++i)
{
m_puiTextures[i] = m_uiLegTex;
SPODMaterial* pMaterial = &m_Scene.pMaterial[i];
if(strcmp(pMaterial->pszName, "Mat_body") == 0)
{
m_puiTextures[i] = m_uiBodyTex;
}
else if(strcmp(pMaterial->pszName, "Mat_legs") == 0)
{
m_puiTextures[i] = m_uiLegTex;
}
else if(strcmp(pMaterial->pszName, "Mat_belt") == 0)
{
m_puiTextures[i] = m_uiBeltTex;
}
}
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 CreateFBOorPBuffer
@Return bool true if no error occured
@Description Attempts to create our FBO if supported or a PBuffer if they
are not.
******************************************************************************/
bool OGLESRenderToTexture::CreateFBOorPBuffer()
{
#if !defined(EGL_NOT_PRESENT)
EGLConfig eglConfig = 0;
EGLint list[9];
#endif
// Find the largest square power of two texture that fits into the viewport
m_i32TexSize = 1;
int iSize = PVRT_MIN(PVRShellGet(prefWidth), PVRShellGet(prefHeight));
while (m_i32TexSize * 2 < iSize) m_i32TexSize *= 2;
// Check for FBO extension
if(CPVRTglesExt::IsGLExtensionSupported("GL_OES_framebuffer_object"))
{
// FBOs are present so we're going to use them
m_eR2TType = eFBO;
// Load the extensions as they are required
m_Extensions.LoadExtensions();
// Check to see if the GL_EXT_discard_framebuffer extension is supported by seeing if
// CPVRTglesExt has a valid pointer for glDiscardFramebufferEXT
m_bDiscard = m_Extensions.glDiscardFramebufferEXT != 0;
// Get the currently bound frame buffer object. On most platforms this just gives 0.
glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &m_i32OriginalFbo);
// Generate and bind a render buffer which will become a depth buffer shared between our two FBOs
m_Extensions.glGenRenderbuffersOES(1, &m_uDepthBuffer);
m_Extensions.glBindRenderbufferOES(GL_RENDERBUFFER_OES, m_uDepthBuffer);
/*
Currently it is unknown to GL that we want our new render buffer to be a depth buffer.
glRenderbufferStorage will fix this and in this case will allocate a depth buffer
m_i32TexSize by m_i32TexSize.
*/
m_Extensions.glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH_COMPONENT16_OES, m_i32TexSize, m_i32TexSize);
}
#if !defined(EGL_NOT_PRESENT)
else
{
// FBOs aren't present so we're going to use PBuffers
m_eR2TType = ePBuffer;
// Set up a configuration and attribute list used for creating a PBuffer surface.
eglConfig = SelectEGLConfig();
// First we specify the width of the surface...
list[0] = EGL_WIDTH;
list[1] = m_i32TexSize;
// ...then the height of the surface...
list[2] = EGL_HEIGHT;
list[3] = m_i32TexSize;
/* ... then we specifiy the target for the texture
that will be created when the pbuffer is created...*/
list[4] = EGL_TEXTURE_TARGET;
list[5] = EGL_TEXTURE_2D;
/*..then the format of the texture that will be created
when the pBuffer is bound to a texture...*/
list[6] = EGL_TEXTURE_FORMAT;
list[7] = EGL_TEXTURE_RGB;
// The final thing is EGL_NONE which signifies the end.
list[8] = EGL_NONE;
/*
Get the current display, context and surface so we can switch between the
PBuffer surface and the main render surface.
*/
m_CurrentDisplay = eglGetCurrentDisplay();
m_CurrentContext = eglGetCurrentContext();
m_CurrentSurface = eglGetCurrentSurface(EGL_DRAW);
}
#else
else
{
