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