/*!****************************************************************************
@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 OGLES2ShadowMapping::InitView()
{
CPVRTString ErrorStr;
if(!CPVRTgles2Ext::IsGLExtensionSupported("GL_OES_depth_texture"))
{
PVRShellSet(prefExitMessage, "Error: Unable to run this training course as it requires extension 'GL_OES_depth_texture'");
return false;
}
m_bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
// Initialize VBO data
if(!LoadVbos(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load textures
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load and compile the shaders & link programs
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Create a frame buffer with only the depth buffer attached
glGenFramebuffers(1, &m_uiFrameBufferObject);
glBindFramebuffer(GL_FRAMEBUFFER, m_uiFrameBufferObject);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_uiShadowMapTexture, 0);
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
PVRShellSet(prefExitMessage, "ERROR: Frame buffer not set up correctly\n");
return false;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Initialize Print3D
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight),m_bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
return true;
}
/*!****************************************************************************
@Function InitView
@Return bool true if no error occurred
@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 dependent on the rendering
context (e.g. textures, vertex buffers, etc.)
******************************************************************************/
bool OGLESPVRScopeRemote::InitView()
{
CPPLProcessingScoped PPLProcessingScoped(m_psSPSCommsData,
__FUNCTION__, static_cast<unsigned int>(strlen(__FUNCTION__)), m_i32FrameCounter);
CPVRTString ErrorStr;
/*
Initialize Print3D
*/
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;
}
// Sets the clear color
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
// Enables texturing
glEnable(GL_TEXTURE_2D);
// Initialize VBO data
if(!LoadVbos(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load textures
*/
if(!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Calculate the projection and view matrices
*/
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PIf/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, bRotate);
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 75.0f), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
// Enable the depth test
glEnable(GL_DEPTH_TEST);
// Enable culling
glEnable(GL_CULL_FACE);
// Initialise variables used for the animation
m_fFrame = 0;
m_iTimePrev = PVRShellGetTime();
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 OGLES3TextureStreaming::InitView()
{
CPVRTString ErrorStr;
// Initialize VBO data
if(!LoadVbos(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load textures
if(!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load and compile the shaders & link programs
if(!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Initialize the textures used by Print3D.
To properly display text, Print3D needs to know the viewport dimensions
and whether the text should be rotated. We get the dimensions using the
shell function PVRShellGet(prefWidth/prefHeight). We can also get the
rotate parameter by checking prefIsRotated and prefFullScreen.
*/
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;
}
//Set OpenGL ES render states needed for this demo
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Sets the clear color
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
// Setup the AV capture
if(!m_Camera.InitialiseSession(ePVRTHWCamera_Front))
return false;
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 OGLES2ChameleonMan::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Initialize Print3D
*/
// Is the screen rotated?
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;
}
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Use black as our clear colour
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
// Initialise variables used for the animation
m_iTimePrev = PVRShellGetTime();
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 OGLES3IntroducingPOD::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
if(!LoadVbos(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load textures
*/
if(!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if(!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Initialize Print3D
*/
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;
}
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
return true;
}
/*!****************************************************************************
@Function InitView
@Return bool true if no error occurred
@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 OGLES3EdgeDetection::InitView()
{
// Store width and height of the viewport.
m_i32TexWidth = PVRShellGet(prefWidth);
m_i32TexHeight = PVRShellGet(prefHeight);
/* Get the current frame buffer object. As the program hasn't set it yet, this is the default buffer.
On most platforms this just gives 0, but there are exceptions. */
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &m_i32OriginalFramebuffer);
// Create string for error codes.
CPVRTString ErrorStr;
// Checks to see if the screen is rotated or not.
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
// Initialize VBO data
if(!LoadVbos(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Initialise Print3D
if(m_Print3D.SetTextures(0,m_i32TexWidth,m_i32TexHeight,bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
// Load external textures and create internal ones.
if(!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load and compile the shaders & link programs
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Creates and checks FBO creation
if (!CreateFBO(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
SetupView(bRotate);
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 OGLES2ParticleSystem::InitView()
{
CPVRTString ErrorStr;
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
// Initialize Print3D textures
if(m_Print3D.SetTextures(0, PVRShellGet(prefWidth), PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
// Load and compile the shaders & link programs
if (!LoadVbos(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load and compile the shaders & link programs
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load and compile the shaders & link programs
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Creates the projection matrix.
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI / 3.0f, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), g_fCameraNear, g_fCameraFar, PVRTMat4::OGL, bRotate);
m_pParticleSystem = new ParticleSystemCPU();
if (!m_pParticleSystem->Init(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
m_pParticleSystem->SetNumberOfParticles(g_ui32InitialNoParticles);
m_pParticleSystem->SetCollisionSpheres(g_caSpheres, g_cuiNumSpheres);
glBindBuffer(GL_ARRAY_BUFFER, 0);
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 OGLES3AlphaBlend::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Get screen rotation state
*/
m_bRotateScreen = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), m_bRotateScreen) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
// Disable the depth test
glDisable(GL_DEPTH_TEST);
// Enable culling
glEnable(GL_CULL_FACE);
return true;
}
/*!****************************************************************************
@Function InitView
@Return bool true if no error occurred
@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 OGLES3PhantomMask::InitView()
{
CPVRTString ErrorStr;
// Initialise VBO data
if(!LoadVbos(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load textures
if(!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load and compile the shaders & link programs
if(!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Initialise Print3D
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;
}
// Initialise the background
if(m_Background.Init(0, bRotate, &ErrorStr) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
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 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 OGLES3Fog::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Is the screen rotated
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
float fAspect = PVRShellGet(prefWidth) / (float)PVRShellGet(prefHeight);
m_mProjection = PVRTMat4::PerspectiveFovFloatDepthRH(CAM_FOV, fAspect, CAM_NEAR, PVRTMat4::OGL, bRotate);
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0.f, 0.f, 150.f), PVRTVec3(0.f), PVRTVec3(0.f, 1.f, 0.f));
/*
Set OpenGL ES render states needed for this training course
*/
// Enable z-buffer test
// We are using a projection matrix optimized for a floating point depth buffer,
// so the depth test and clear value need to be inverted (1 becomes near, 0 becomes far).
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_GEQUAL);
glClearDepthf(0.0f);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
/*
Set up constant fog shader uniforms
*/
const float fFogStart = 0.0f;
const float fFogEnd = 1200.0f;
const float fFogDensity = 0.002f;
const float fFogRcpEndStartDiff = 1.0f / (fFogEnd - fFogStart);
const float afFogColor[3] = { 0.6f, 0.8f, 1.0f }; // the fog RGB color
glUniform1f(m_ShaderProgram.uiFogEndLoc, fFogEnd);
glUniform1f(m_ShaderProgram.uiFogRcpDiffLoc, fFogRcpEndStartDiff);
glUniform1f(m_ShaderProgram.uiFogDensityLoc, fFogDensity);
glUniform3fv(m_ShaderProgram.uiFogColorLoc, 1, afFogColor);
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 OGLES3ComplexLighting::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Set default light color and position
float afLightPosition[] = { 0, 0, -120 };
float afLightDirection[] = { 0, 0, 1 };
float afLightColor[] = { 1, 1, 1 };
glUniform3fv(m_ShaderProgram.uiLightPosLoc, 1, afLightPosition);
glUniform3fv(m_ShaderProgram.uiLightDirLoc, 1, afLightDirection);
glUniform3fv(m_ShaderProgram.uiLightColorLoc, 1, afLightColor);
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
float fAspect = PVRShellGet(prefWidth) / (float)PVRShellGet(prefHeight);
m_mProjection = PVRTMat4::PerspectiveFovFloatDepthRH(CAM_FOV, fAspect, CAM_NEAR, PVRTMat4::OGL, bRotate);
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 150), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
// Enable z-buffer test
// We are using a projection matrix optimized for a floating point depth buffer,
// so the depth test and clear value need to be inverted (1 becomes near, 0 becomes far).
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_GEQUAL);
glClearDepthf(0.0f);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
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 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 OGLES2PVRScopeRemote::InitView()
{
CPPLProcessingScoped PPLProcessingScoped(m_psSPSCommsData,
__FUNCTION__, static_cast<unsigned int>(strlen(__FUNCTION__)), m_i32FrameCounter);
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Take our initial vert shader source
{
CPVRTResourceFile VertShaderFile(c_szVertShaderSrcFile);
m_pszVertShader = new char[VertShaderFile.Size() + 1];
strncpy(m_pszVertShader, (char*)VertShaderFile.DataPtr(), VertShaderFile.Size());
m_pszVertShader[VertShaderFile.Size()] = 0;
}
// Take our initial frag shader source
{
CPVRTResourceFile FragShaderFile(c_szFragShaderSrcFile);
m_pszFragShader = new char[FragShaderFile.Size() + 1];
strncpy(m_pszFragShader, (char*)FragShaderFile.DataPtr(), FragShaderFile.Size());
m_pszFragShader[FragShaderFile.Size()] = 0;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr, m_pszFragShader, m_pszVertShader))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, bRotate);
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 75), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
return true;
}
/*!****************************************************************************
@Function InitView
@Return bool true if no error occurred
@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 OGLES3MagicLantern::InitView()
{
CPVRTString ErrorStr;
// At this point m_Scene should have been already processed by InitApplication()
// and all the POD data properly loaded, but lets do a little test just in case.
if (!m_Scene.IsLoaded())
{
PVRShellSet(prefExitMessage, "ERROR: POD file has not been loaded correctly. Cannot continue. \n");
return false;
}
// Initialize VBO data
if(!LoadVbos())
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load and compile the shaders, link programs and load textures.
if(!LoadPFX())
{
return false;
}
// Initialize Print3D
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;
}
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Black as clear colour
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
// Disable blending
glDisable(GL_BLEND);
// Set up the view and projection matrices from the camera.
// The camera does not moves so these matrices only need to be
// calculated once.
// If you want to make the camera dynamic, re-calculate the view matrix
// every frame.
PVRTVec3 vFrom, vTo(0.0f), vUp(0.0f, 1.0f, 0.0f);
float fFOV;
// Camera nodes are after the mesh and light nodes in the array.
// We grab camera num 0 (the only one in the scene)
const int g_ui32Camera = 0;
int i32CamID = m_Scene.pNode[m_Scene.nNumMeshNode + m_Scene.nNumLight + g_ui32Camera].nIdx;
// Get the camera position and target
if(m_Scene.pCamera[i32CamID].nIdxTarget != -1) // Does the camera have a target?
m_Scene.GetCameraPos( vFrom, vTo, g_ui32Camera); // vTo is taken from the target node.
else
m_Scene.GetCamera( vFrom, vTo, vUp, g_ui32Camera); // vTo is calculated from the rotation.
// Calculate the FOV depending of the screen dimensions so everything fit in view
// regardless whether the screen is rotated or not.
// if the aspect ratio is different than 640x480 adapt FOV so the scene still looks correct.
float fRatioWoverH = (480.0f/640.0f) * ((!bRotate) ? (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight) : (float)PVRShellGet(prefHeight)/(float)PVRShellGet(prefWidth));
fFOV = m_Scene.pCamera[i32CamID].fFOV / fRatioWoverH;
// We can build the model view matrix from the camera position, target and an up vector.
m_mView = PVRTMat4::LookAtRH(vFrom, vTo, vUp);
// Calculate the projection matrix.
m_mProjection = PVRTMat4::PerspectiveFovRH(fFOV, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), m_Scene.pCamera[i32CamID].fNear, m_Scene.pCamera[i32CamID].fFar, PVRTMat4::OGL, bRotate);
return true;
}
/*!****************************************************************************
@Function InitView
@Return bool true if no error occurred
@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 OGLES2ParallaxBumpMap::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Set the sampler2D uniforms to corresponding texture units
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "basemap"), 0);
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "normalmap"), 1);
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "heightmap"), 2);
// Is the screen rotated
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
float fAspect = PVRShellGet(prefWidth) / (float)PVRShellGet(prefHeight);
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 150), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
m_mViewProj = PVRTMat4::PerspectiveFovFloatDepthRH(CAM_FOV, fAspect, CAM_NEAR, PVRTMat4::OGL, bRotate);
m_mViewProj *= m_mView;
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
// Enable z-buffer test
// We are using a projection matrix optimized for a floating point depth buffer,
// so the depth test and clear value need to be inverted (1 becomes near, 0 becomes far).
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_GEQUAL);
glClearDepthf(0.0f);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
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, (float)PVRShellGet(prefWidth) / (float)PVRShellGet(prefHeight), g_fNear, g_fFar, PVRTMat4::OGL, bRotate);
glLoadMatrixf(m_mProj.f);
// Set clear colour
glClearColor(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())
{
PVRShellSet(prefExitMessage, "Failed to create VBOs");
return false;
}
// Initialise camera
m_Scene.GetCameraPos(m_vCamFrom, m_vCamTo, 0);
m_vCamFrom = PVRTVec3(0.0f, 400.0f, 0.0f);
// Enable fog
glFogf(GL_FOG_MODE, GL_EXP2);
glFogf(GL_FOG_DENSITY, c_fFogDensity);
glFogfv(GL_FOG_COLOR, &c_vFogColour.x);
glEnable(GL_FOG);
// Enable lighting
glLightfv(GL_LIGHT0, GL_POSITION, &c_vLightPosition.x);
glLightfv(GL_LIGHT0, GL_DIFFUSE, &c_vLightColour.x);
glLightfv(GL_LIGHT0, GL_AMBIENT, &c_vLightAmbient.x);
glLightfv(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 InitView
@Return bool true if no error occurred
@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 OGLES2FilmTV::InitView()
{
CPVRTString ErrorStr;
// Initialize VBO data
if(!LoadVbos(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load textures
if(!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load and compile the shaders & link programs
if(!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Initialize Print3D
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;
}
//Set OpenGL ES render states needed for this demo
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
// 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;
// Get the currently bound frame buffer object. On most platforms this just gives 0.
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &m_i32OriginalFB);
for(int i = 0; i < 2; ++i)
{
// Create texture for the FBO
glGenTextures(1, &m_uiTexture[i]);
glBindTexture(GL_TEXTURE_2D, m_uiTexture[i]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_i32TexSize, m_i32TexSize, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Create FBO
glGenFramebuffers(1, &m_uiFbo[i]);
glBindFramebuffer(GL_FRAMEBUFFER, m_uiFbo[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_uiTexture[i], 0);
glGenRenderbuffers(1, &m_uiDepthBuffer[i]);
glBindRenderbuffer(GL_RENDERBUFFER, m_uiDepthBuffer[i]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, m_i32TexSize, m_i32TexSize);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_uiDepthBuffer[i]);
// Check that our FBO creation was successful
GLuint uStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if(uStatus != GL_FRAMEBUFFER_COMPLETE)
{
m_bFBOsCreated = false;
PVRShellOutputDebug("ERROR: Failed to initialise FBO");
break;
}
// Clear the colour buffer for this FBO
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glBindFramebuffer(GL_FRAMEBUFFER, m_i32OriginalFB);
// Setup the main camera
PVRTVec3 vFrom, vTo(0.0f), vUp(0.0f, 1.0f, 0.0f);
float fFOV;
// Camera nodes are after the mesh and light nodes in the array
int i32CamID = m_Scene.pNode[m_Scene.nNumMeshNode + m_Scene.nNumLight + g_ui32Camera].nIdx;
// Get the camera position, target and field of view (fov)
if(m_Scene.pCamera[i32CamID].nIdxTarget != -1) // Does the camera have a target?
fFOV = m_Scene.GetCameraPos( vFrom, vTo, g_ui32Camera); // vTo is taken from the target node
else
fFOV = m_Scene.GetCamera( vFrom, vTo, vUp, g_ui32Camera); // vTo is calculated from the rotation
m_View = PVRTMat4::LookAtRH(vFrom, vTo, vUp);
// Calculate the projection matrix
PVRTMat4 mProjection = PVRTMat4::PerspectiveFovRH(fFOV, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), g_fCameraNear, g_fCameraFar, PVRTMat4::OGL, bRotate);
m_ViewProjection = mProjection * m_View;
// Check to see if the GL_EXT_discard_framebuffer extension is supported
if(m_bFBOsCreated && (m_bDiscard = CPVRTgles2Ext::IsGLExtensionSupported("GL_EXT_discard_framebuffer")) != false)
{
m_Extensions.LoadExtensions();
m_bDiscard = m_Extensions.glDiscardFramebufferEXT != 0;
}
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 OGLES3ShadowVolumes::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Set the sampler2D uniforms to corresponding texture units
glUseProgram(m_BaseShader.uiId);
glUniform1i(glGetUniformLocation(m_BaseShader.uiId, "sTexture"), 0);
/*
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] = 0;
SPODMaterial* pMaterial = &m_Scene.pMaterial[i];
if (!strcmp(pMaterial->pszName, "background"))
{
m_puiTextures[i] = m_uiBackgroundTex;
}
else if (!strcmp(pMaterial->pszName, "rust"))
{
m_puiTextures[i] = m_uiRustTex;
}
}
// Go through the object type and find out how many shadows we are going to need
m_ui32NoOfShadows = 0;
for (int i = 0; i < eNumMeshes; ++i)
{
if(m_i32ObjectType[i] != eDoesntCast) ++m_ui32NoOfShadows;
}
// Build the shadow volumes and meshes
// Create the number of shadow meshes and volumes we require
m_pShadowMesh = new PVRTShadowVolShadowMesh[m_ui32NoOfShadows];
m_pShadowVol = new PVRTShadowVolShadowVol [m_ui32NoOfShadows];
// Create the array that stores the SPODNode ID for each shadow
m_pui32MeshIndex = new unsigned int[m_ui32NoOfShadows];
// Go through the meshes and initialise the shadow meshes, volumes and mesh index for each requried shadow
int i32Index = 0;
for (int i = 0; i < eNumMeshes; ++i)
{
if(m_i32ObjectType[i] != eDoesntCast)
{
m_pui32MeshIndex[i32Index] = i;
SPODNode* pNode = &m_Scene.pNode[i];
/*
This function will take the POD mesh referenced by the current node and generate a
new mesh suitable for creating shadow volumes and the shadow volume itself.
*/
BuildShadowVolume(&m_pShadowMesh[i32Index], &m_pShadowVol[i32Index], &m_Scene.pMesh[pNode->nIdx]);
/*
The function will initialise the shadow volume with regard to the meshes current transformation
and the light position.
As the light position is fixed this is only done once for static objects where as dynamic objects
are updated every frame.
*/
BuildVolume(i32Index, &m_vLightPosWorld);
++i32Index;
}
}
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
// Calculate the view matrix
PVRTVec3 vFrom, vTo;
float fFOV;
// We can get the camera position, target and field of view (fov) with GetCamera()
fFOV = m_Scene.GetCameraPos( vFrom, vTo, 0);
m_mView = PVRTMat4::LookAtRH(vFrom, vTo, PVRTVec3(0, 1, 0));
// Calculate the projection matrix
m_mProjection = PVRTMat4::PerspectiveFovRH(fFOV, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, bRotate);
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
glClearStencil(0);
m_ulTimePrev = PVRShellGetTime();
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 OGLES2FastTnL::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
float fAspect = PVRShellGet(prefWidth) / (float)PVRShellGet(prefHeight);
m_mViewProj = PVRTMat4::PerspectiveFovFloatDepthRH(CAM_FOV, fAspect, CAM_NEAR, PVRTMat4::OGL, bRotate);
m_mViewProj *= PVRTMat4::LookAtRH(PVRTVec3(0.f, 0.f, 150.f), PVRTVec3(0.f), PVRTVec3(0.f, 1.f, 0.f));
/*
Set default shader material uniforms
*/
float fSpecularConcentration = 0.8f; // a value from 0 to 1 (wider, concetrated)
float fSpecularIntensity = 0.5f; // a value from 0 to 1
// Specular bias
glUniform1f(m_ShaderProgram.uiMaterialBiasLoc, fSpecularConcentration);
// Specular intensity scale
glUniform1f(m_ShaderProgram.uiMaterialScaleLoc, fSpecularIntensity / (1.0f - fSpecularConcentration));
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
// Enable z-buffer test
// We are using a projection matrix optimized for a floating point depth buffer,
// so the depth test and clear value need to be inverted (1 becomes near, 0 becomes far).
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_GEQUAL);
glClearDepthf(0.0f);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
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 OGLES3ShadowMapping::InitView()
{
CPVRTString ErrorStr;
m_bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
// Initialize VBO data
if(!LoadVbos(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load textures
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Load and compile the shaders & link programs
if (!LoadPFX(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Map the individual effects to make it easier to address them
for (unsigned int i=0; i < m_pPFXEffectParser->GetNumberEffects(); i++)
{
// Store the indices for the individual effects
if (m_pPFXEffectParser->GetEffect(i).Name == c_RenderShadowMapEffectName)
m_iEffectIndex[INDEX_RENDERSHADOW] = i;
else if (m_pPFXEffectParser->GetEffect(i).Name == c_RenderSceneEffectName)
m_iEffectIndex[INDEX_RENDERSCENE] = i;
}
if (!CreateFBO(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Initialize Print3D
if (m_Print3D.SetTextures(0, PVRShellGet(prefWidth), PVRShellGet(prefHeight),m_bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialize Print3D\n");
return false;
}
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
// Enable culling
glEnable(GL_CULL_FACE);
// and depth testing
glEnable(GL_DEPTH_TEST);
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 OGLESRenderToTexture::InitView()
{
CPVRTString ErrorStr;
/*
Initialise Print3D
*/
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;
}
// Enables texturing
glEnable(GL_TEXTURE_2D);
// Initialize VBO data
if(!LoadVbos(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load textures
*/
if(!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Create a FBO or PBuffer
if(!CreateFBOorPBuffer())
return false;
// Setup some render states
// Enable the depth test
glEnable(GL_DEPTH_TEST);
// Enable culling
glEnable(GL_CULL_FACE);
// Setup the material parameters our meshes will use
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, PVRTVec4(1.0f).ptr());
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, PVRTVec4(1.0f).ptr());
// Setup view and projection matrices used for when rendering to the texture
// Caculate the view matrix
m_mR2TView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 60), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
// Calculate the projection matrix
// Note: As we'll be rendering to a texture we don't need to take the screen rotation into account
m_mR2TProjection = PVRTMat4::PerspectiveFovRH(1, 1, g_fCameraNear, g_fCameraFar, PVRTMat4::OGL, false);
// Setup view and projection matrices used for when rendering the main scene
// Caculate the view matrix
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 125), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
// Calculate the projection matrix
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), g_fCameraNear, g_fCameraFar, PVRTMat4::OGL, bRotate);
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 OGLES3Skinning::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Set the sampler2D uniforms to corresponding texture units
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sTexture"), 0);
/*
Initialize Print3D
*/
// Is the screen rotated?
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;
}
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
/*
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 OGLES2PVRScopeExample::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, bRotate);
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 75), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
// set thickness variation of the film
m_fMaxVariation = 100.0f;
// set the minimum thickness of the film
m_fMinThickness = 100.0f;
// Initialise the graphing code
m_pScopeGraph = new CPVRScopeGraph();
if(m_pScopeGraph)
{
// Position the graph
m_pScopeGraph->position(PVRShellGet(prefWidth), PVRShellGet(prefHeight), (int) (PVRShellGet(prefWidth) * 0.02f), (int) (PVRShellGet(prefHeight) * 0.02f), (int) (PVRShellGet(prefWidth) * 0.96f), (int) (PVRShellGet(prefHeight) * 0.96f) / 3);
// Output the current active group and a list of all the counters
PVRShellOutputDebug("Active Group %i\nCounter Number %i\n", m_pScopeGraph->GetActiveGroup(), m_pScopeGraph->GetCounterNum());
PVRShellOutputDebug("Counters\n");
for(unsigned int i = 0; i < m_pScopeGraph->GetCounterNum(); ++i)
{
PVRShellOutputDebug("(%i) Name %s Group %i %s\n", i,
m_pScopeGraph->GetCounterName(i), m_pScopeGraph->GetCounterGroup(i),
m_pScopeGraph->IsCounterPercentage(i) ? "percentage" : "absolute");
m_pScopeGraph->ShowCounter(i, false);
}
// Set the active group to 0
m_pScopeGraph->SetActiveGroup(m_i32Group);
// Tell the graph to show an initial counter
m_pScopeGraph->ShowCounter(m_i32Counter, true);
// Set the update interval: number of updates [frames] before updating the graph
m_pScopeGraph->SetUpdateInterval(m_i32Interval);
}
return true;
}
/*!****************************************************************************
@Function InitView
@Return bool true if no error occurred
@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 OGLES2Glass::InitView()
{
CPVRTString ErrorStr;
// Store the original FBO handle
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &m_iOriginalFramebuffer);
/*
Initialize VBO data
*/
LoadVbos();
if (!LoadParaboloids(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
// Set the sampler2D uniforms to corresponding texture units
glUseProgram(m_DefaultProgram.uiId);
glUniform1i(glGetUniformLocation(m_DefaultProgram.uiId, "s2DMap"), 0);
glUseProgram(m_SkyboxProgram.uiId);
glUniform1i(glGetUniformLocation(m_SkyboxProgram.uiId, "sSkybox"), 0);
glUseProgram(m_ParaboloidProgram.uiId);
glUniform1i(glGetUniformLocation(m_ParaboloidProgram.uiId, "s2DMap"), 0);
glUniform1f(glGetUniformLocation(m_ParaboloidProgram.uiId, "Near"), g_fCamNear);
glUniform1f(glGetUniformLocation(m_ParaboloidProgram.uiId, "Far"), g_fCamFar);
for (int i = 0; i < g_iNumEffects; ++i) {
glUseProgram(m_aEffectPrograms[i].uiId);
glUniform1i(glGetUniformLocation(m_aEffectPrograms[i].uiId, "sParaboloids"), 0);
glUniform1i(glGetUniformLocation(m_aEffectPrograms[i].uiId, "sSkybox"), 1);
}
/*
Calculate the projection and view matrices
*/
m_mProjection = PVRTMat4::PerspectiveFovRH(g_fCamFOV, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), g_fCamNear, g_fCamFar, PVRTMat4::OGL, bRotate);
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 0.0f);
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 OGLES3Refraction::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Set the sampler2D uniforms to corresponding texture units
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sTexture"), 0);
// Is the screen rotated?
m_bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), m_bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Initalise the background
*/
if(m_Background.Init(0, m_bRotate, &ErrorStr) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Calculate the projection and view matrices
*/
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, m_bRotate);
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 150), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
/*
Set OpenGL ES render states needed for this training course
*/
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
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 OGLES2AnisotropicLighting::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
float fAspect = PVRShellGet(prefWidth) / (float)PVRShellGet(prefHeight);
m_mViewProj = PVRTMat4::PerspectiveFovFloatDepthRH(CAM_FOV, fAspect, CAM_NEAR, PVRTMat4::OGL, bRotate);
m_mViewProj *= PVRTMat4::LookAtRH(PVRTVec3(0.f, 0.f, 150.f), PVRTVec3(0.f), PVRTVec3(0.f, 1.f, 0.f));
/*
Set uniforms that are constant throughout this training course
*/
// Set the sampler2D variable to the first texture unit
glUseProgram(m_FastShader.uiId);
glUniform1i(glGetUniformLocation(m_FastShader.uiId, "sTexture"), 0);
// Define material properties
glUseProgram(m_SlowShader.uiId);
float afMaterial[4] = {
0.4f, // Diffuse intensity scale
0.6f, // Diffuse intensity bias
0.82f, // Specular intensity scale
0.0f, // Specular bias
};
glUniform4fv(glGetUniformLocation(m_SlowShader.uiId, "Material"), 1, afMaterial);
// Set surface grain direction
PVRTVec3 vMsGrainDir = PVRTVec3(2, 1, 0).normalized();
glUniform3fv(glGetUniformLocation(m_SlowShader.uiId, "GrainDir"), 1, vMsGrainDir.ptr());
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
// Enable z-buffer test
// We are using a projection matrix optimized for a floating point depth buffer,
// so the depth test and clear value need to be inverted (1 becomes near, 0 becomes far).
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_GEQUAL);
glClearDepthf(0.0f);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
m_fAngleY = 0;
m_eRenderMode = eTexLookup;
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 OGLES2LevelOfDetail::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Set the sampler2D uniforms to corresponding texture units
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sReflectTex"), 0);
glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sNormalMap"), 1);
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, bRotate);
m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 150), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0));
/*
Set OpenGL ES render states needed for this training course
*/
// Enable backface culling and depth test
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
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 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 OGLES3AlphaTest::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
LoadVbos();
/*
Load textures
*/
if (!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Load and compile the shaders & link programs
*/
if (!LoadShaders(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Is the screen rotated?
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/*
Initialize Print3D
*/
if(m_Print3D.SetTextures(0, PVRShellGet(prefWidth), PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
/*
Calculate the projection and view matrices
*/
float fAspect = PVRShellGet(prefWidth) / (float)PVRShellGet(prefHeight);
m_mViewProj = PVRTMat4::PerspectiveFovFloatDepthRH(g_fFOV, fAspect, g_fNear, PVRTMat4::OGL, bRotate);
m_mViewProj *= PVRTMat4::LookAtRH(PVRTVec3(0, 2, -2.5f), PVRTVec3(0, 0.2f, 0), PVRTVec3(0, 1, 0));
/*
Set OpenGL ES render states needed for this training course
*/
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
// Enable z-buffer test
// We are using a projection matrix optimized for a floating point depth buffer,
// so the depth test and clear value need to be inverted (1 becomes near, 0 becomes far).
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_GEQUAL);
glClearDepthf(0.0f);
return true;
}
