/*!****************************************************************************
@Function LoadShaders
@Output pErrorStr A string describing the error on failure
@Return bool true if no error occured
@Description Loads and compiles the shaders and links the shader programs
required for this training course
******************************************************************************/
bool OGLES2StencilBuffer::LoadShaders(CPVRTString* pErrorStr)
{
/*
Load and compile the shaders from files.
Binary shaders are tried first, source shaders
are used as fallback.
*/
if (PVRTShaderLoadFromFile(
c_szVertShaderBinFile, c_szVertShaderSrcFile, GL_VERTEX_SHADER, GL_SGX_BINARY_IMG, &m_uiVertShader, pErrorStr) != PVR_SUCCESS)
{
return false;
}
if (PVRTShaderLoadFromFile(
c_szFragShaderBinFile, c_szFragShaderSrcFile, GL_FRAGMENT_SHADER, GL_SGX_BINARY_IMG, &m_uiFragShader, pErrorStr) != PVR_SUCCESS)
{
return false;
}
/*
Set up and link the shader program
*/
if (PVRTCreateProgram(&m_ShaderProgram.uiId, m_uiVertShader, m_uiFragShader, g_aszAttribNames, eNumAttribs, pErrorStr) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
// Store the location of uniforms for later use
for (int i = 0; i < eNumUniforms; ++i)
{
m_ShaderProgram.auiLoc[i] = glGetUniformLocation(m_ShaderProgram.uiId, g_aszUniformNames[i]);
}
return true;
}
/*!****************************************************************************
@Function InitApplication
@Return bool true if no error occurred
@Description Code in InitApplication() will be called by PVRShell once per
run, before the rendering context is created.
Used to initialize variables that are not dependent on it
(e.g. external modules, loading meshes, etc.)
If the rendering context is lost, InitApplication() will
not be called again.
******************************************************************************/
bool OGLES2ParallaxBumpMap::InitApplication()
{
m_puiVbo = 0;
m_puiIndexVbo = 0;
// Get and set the read path for content files
CPVRTResourceFile::SetReadPath((char*)PVRShellGet(prefReadPath));
// Get and set the load/release functions for loading external files.
// In the majority of cases the PVRShell will return NULL function pointers implying that
// nothing special is required to load external files.
CPVRTResourceFile::SetLoadReleaseFunctions(PVRShellGet(prefLoadFileFunc), PVRShellGet(prefReleaseFileFunc));
// Load the scene
if (m_Scene.ReadFromFile(c_szSceneFile) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Couldn't load the .pod file\n");
return false;
}
m_fAngleY = 0.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 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 LoadShaders
@Output pErrorStr A string describing the error on failure
@Return bool true if no error occured
@Description Loads and compiles the shaders and links the shader programs
required for this training course
******************************************************************************/
bool OGLES2AnisotropicLighting::LoadShaders(CPVRTString* pErrorStr)
{
/*
Load and compile the shaders from files.
Binary shaders are tried first, source shaders
are used as fallback.
*/
if (PVRTShaderLoadFromFile(c_szFastVsBinFile,
c_szFastVsSrcFile,
GL_VERTEX_SHADER,
GL_SGX_BINARY_IMG,
&m_uiFastVertShader,
pErrorStr) != PVR_SUCCESS)
{
*pErrorStr = CPVRTString("From file '") + c_szFastVsBinFile +
"' or '" + c_szFastVsSrcFile + "':\n" + *pErrorStr;
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
if (PVRTShaderLoadFromFile(c_szFastFsBinFile,
c_szFastFsSrcFile,
GL_FRAGMENT_SHADER,
GL_SGX_BINARY_IMG,
&m_uiFastFragShader,
pErrorStr) != PVR_SUCCESS)
{
*pErrorStr = CPVRTString("From file '") + c_szFastVsBinFile +
"' or '" + c_szFastVsSrcFile + "':\n" + *pErrorStr;
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
if (PVRTShaderLoadFromFile(c_szSlowVsBinFile,
c_szSlowVsSrcFile,
GL_VERTEX_SHADER,
GL_SGX_BINARY_IMG,
&m_uiSlowVertShader,
pErrorStr) != PVR_SUCCESS)
{
*pErrorStr = CPVRTString("From file '") + c_szFastVsBinFile +
"' or '" + c_szFastVsSrcFile + "':\n" + *pErrorStr;
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
if (PVRTShaderLoadFromFile(c_szSlowFsBinFile,
c_szSlowFsSrcFile,
GL_FRAGMENT_SHADER,
GL_SGX_BINARY_IMG,
&m_uiSlowFragShader,
pErrorStr) != PVR_SUCCESS)
{
*pErrorStr = CPVRTString("From file '") + c_szFastVsBinFile +
"' or '" + c_szFastVsSrcFile + "':\n" + *pErrorStr;
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
/*
Set up and link the shader programs
*/
const char* aszAttribs[] = { "inVertex", "inNormal" };
if (
(PVRTCreateProgram(&m_FastShader.uiId, m_uiFastVertShader, m_uiFastFragShader, aszAttribs, 2, pErrorStr) != PVR_SUCCESS) ||
(PVRTCreateProgram(&m_SlowShader.uiId, m_uiSlowVertShader, m_uiSlowFragShader, aszAttribs, 2, pErrorStr) != PVR_SUCCESS)
)
{
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
/*
Store the location of uniforms for later use
*/
m_FastShader.uiMVPMatrixLoc = glGetUniformLocation(m_FastShader.uiId, "MVPMatrix");
m_FastShader.uiMsLightDirLoc = glGetUniformLocation(m_FastShader.uiId, "msLightDir");
m_FastShader.uiMsEyePosLoc = glGetUniformLocation(m_FastShader.uiId, "msEyePos");
m_SlowShader.uiMVPMatrixLoc = glGetUniformLocation(m_SlowShader.uiId, "MVPMatrix");
m_SlowShader.uiMsLightDirLoc = glGetUniformLocation(m_SlowShader.uiId, "msLightDir");
m_SlowShader.uiMsEyeDirLoc = glGetUniformLocation(m_SlowShader.uiId, "msEyeDir");
return true;
}
/*******************************************************************************
* Function Name : InitApplication
* Returns : true if no error occured
* Description : Code in InitApplication() will be called by the Shell ONCE per
* run, early on in the execution of the program.
* Used to initialise variables that are not dependent on the
* rendering context (e.g. external modules, loading meshes, etc.)
*******************************************************************************/
bool CChildImage::InitApplication()
{
// This sets up PVRShell to use an OpenVG context
PVRShellSet(prefOpenVGContext, true);
return true;
}
/*!****************************************************************************
@Function InitApplication
@Return bool true if no error occurred
@Description Code in InitApplication() will be called by PVRShell once per
run, before the rendering context is created.
Used to initialize variables that are not dependent on it
(e.g. external modules, loading meshes, etc.)
If the rendering context is lost, InitApplication() will
not be called again.
******************************************************************************/
bool OGLESPVRScopeRemote::InitApplication()
{
// We want a data connection to PVRPerfServer
{
m_psSPSCommsData = pplInitialise("PVRScopeRemote", 14);
m_bCommsError = false;
// Demonstrate that there is a good chance of the initial data being
// lost - the connection is normally completed asynchronously.
pplSendMark(m_psSPSCommsData, "lost", static_cast<unsigned int>(strlen("lost")));
// This is entirely optional. Wait for the connection to succeed, it will
// timeout if e.g. PVRPerfServer is not running.
int nBoolConnected;
pplWaitForConnection(m_psSPSCommsData, &nBoolConnected, 1, 200);
}
CPPLProcessingScoped PPLProcessingScoped(m_psSPSCommsData,
__FUNCTION__, static_cast<unsigned int>(strlen(__FUNCTION__)), m_i32FrameCounter);
// set thickness variation of the film
m_fMaxVariation = 100.0f;
// set the minimum thickness of the film
m_fMinThickness = 100.0f;
m_i32FrameCounter = 0;
m_i32Frame10Counter = 0;
// Get and set the read path for content files
CPVRTResourceFile::SetReadPath((char*)PVRShellGet(prefReadPath));
// Get and set the load/release functions for loading external files.
// In the majority of cases the PVRShell will return NULL function pointers implying that
// nothing special is required to load external files.
CPVRTResourceFile::SetLoadReleaseFunctions(PVRShellGet(prefLoadFileFunc), PVRShellGet(prefReleaseFileFunc));
/*
Loads the scene from the .pod file into a CPVRTModelPOD object.
We could also export the scene as a header file and
load it with ReadFromMemory().
*/
if(m_Scene.ReadFromFile(c_szSceneFile) != PVR_SUCCESS)
{
CPVRTString ErrorStr = "ERROR: Couldn't load '" + CPVRTString(c_szSceneFile) + "'.";
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*
Remotely editable library items
*/
if(m_psSPSCommsData)
{
SSPSCommsLibraryItem asItems[8];
unsigned int nItemCount = 0;
// Want editable: min thickness
m_sCommsLibMinThickness.fCurrent = m_fMinThickness;
m_sCommsLibMinThickness.fMin = 0.0f;
m_sCommsLibMinThickness.fMax = 500.0f;
asItems[nItemCount].pszName = "min thickness";
asItems[nItemCount].nNameLength = (unsigned int)strlen(asItems[nItemCount].pszName);
asItems[nItemCount].eType = eSPSCommsLibTypeFloat;
asItems[nItemCount].pData = (const char*)&m_sCommsLibMinThickness;
asItems[nItemCount].nDataLength = sizeof(m_sCommsLibMinThickness);
++nItemCount;
// Want editable: max variation
m_sCommsLibMaxVariation.fCurrent = m_fMaxVariation;
m_sCommsLibMaxVariation.fMin = 50.0f;
m_sCommsLibMaxVariation.fMax = 150.0f;
asItems[nItemCount].pszName = "max variation";
asItems[nItemCount].nNameLength = (unsigned int)strlen(asItems[nItemCount].pszName);
asItems[nItemCount].eType = eSPSCommsLibTypeFloat;
asItems[nItemCount].pData = (const char*)&m_sCommsLibMaxVariation;
asItems[nItemCount].nDataLength = sizeof(m_sCommsLibMaxVariation);
++nItemCount;
_ASSERT(nItemCount < sizeof(asItems) / sizeof(*asItems));
/*
Ok, submit our library
*/
if(!pplLibraryCreate(m_psSPSCommsData, asItems, nItemCount))
{
PVRShellOutputDebug("PVRScopeRemote: pplLibraryCreate() failed\n");
}
}
/*
User defined counters
*/
if(m_psSPSCommsData)
{
SSPSCommsCounterDef asDefs[eCounterNum];
for(unsigned int i = 0; i < eCounterNum; ++i)
{
asDefs[i].pszName = c_apszDefs[i];
asDefs[i].nNameLength = (unsigned int)strlen(c_apszDefs[i]);
}
if(!pplCountersCreate(m_psSPSCommsData, asDefs, eCounterNum))
{
PVRShellOutputDebug("PVRScopeRemote: pplCountersCreate() failed\n");
}
}
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 initialise variables that are dependent on the rendering
* context (e.g. textures, vertex buffers, etc.)
*******************************************************************************/
bool OVGMaskLayer::InitView()
{
// Get screen dimensions
m_ui32ScreenWidth = PVRShellGet(prefWidth);
m_ui32ScreenHeight= PVRShellGet(prefHeight);
// Create the paths so we have something to look at.
CreatePath();
// Set the render quality so the stroke borders have some form of anti-aliasing
vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER);
// Create the paints that the paths will use
m_avgColourPaint[0] = vgCreatePaint();
vgSetParameteri(m_avgColourPaint[0], VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetColor(m_avgColourPaint[0], PVRTRGBA(255,255,15,255));
m_avgColourPaint[1] = vgCreatePaint();
vgSetParameteri(m_avgColourPaint[1], VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetColor(m_avgColourPaint[1], PVRTRGBA(255,50,0, 255));
m_avgColourPaint[2] = vgCreatePaint();
vgSetParameteri(m_avgColourPaint[2], VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetColor(m_avgColourPaint[2], PVRTRGBA(50,250,15, 255));
/*
Load the images we're going to use to modify the mask layer.
For more details on masking please refer to our OVGMasking training course
*/
// Create the VGImages.
VGImage vgMaskImg, vgMaskImg2;
// Using the PVR Tools we're going to load the mask data from a pvr file
if(PVRTImageLoadFromPVR(c_szMask1File, &vgMaskImg) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "Error: Failed to open mask1.pvr.");
return false;
}
if(PVRTImageLoadFromPVR(c_szMask2File, &vgMaskImg2) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "Error: Failed to open mask2.pvr.");
return false;
}
/*
Create a mask layer
A VGMaskLayer is an object that allows you to store and manipulate the drawing surface's mask layer
*/
m_vgMaskLayer[0] = vgCreateMaskLayer(m_ui32ScreenWidth, m_ui32ScreenHeight);
if(m_vgMaskLayer[0] == 0)
{
PVRShellSet(prefExitMessage, "Error: Failed to create mask layer.");
return false;
}
// Tile the first image in the drawing surface's masking layer
TileImageInMask(vgMaskImg, VG_SET_MASK);
/*
Copy the contents of the drawing surface mask layer into our mask layer object
vgCopyMask has the following parameters
VGMaskLayer maskLayer, VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height)
where
masklayer is the masklayer to copy to
dx, dy are the coordinates to start the copy at in the masklayer
sx, sy are the coordinates to start the copy from in the source mask layer
width and the height are the width and height of the region you wish to copy.
In our case we're copying the full mask layer.
*/
vgCopyMask(m_vgMaskLayer[0], 0, 0, 0, 0, m_ui32ScreenWidth, m_ui32ScreenHeight);
// Create the second mask layer
m_vgMaskLayer[1] = vgCreateMaskLayer(m_ui32ScreenWidth, m_ui32ScreenHeight);
if(m_vgMaskLayer[1] == 0)
{
PVRShellSet(prefExitMessage, "Error: Failed to create mask layer.");
return false;
}
// Replace the contents of the mask by tiling the second image
TileImageInMask(vgMaskImg2, VG_SET_MASK);
// Copy the contents of the mask into the second mask layer
vgCopyMask(m_vgMaskLayer[1], 0, 0, 0, 0, m_ui32ScreenWidth, m_ui32ScreenHeight);
// Destroy the images as they are no longer needed
vgDestroyImage(vgMaskImg);
vgDestroyImage(vgMaskImg2);
// Set the mask to ones
vgMask(VG_INVALID_HANDLE, VG_FILL_MASK, 0, 0, m_ui32ScreenWidth, m_ui32ScreenHeight);
// Init PrintVG
m_PrintVG.Initialize(m_ui32ScreenWidth, m_ui32ScreenHeight);
// Setup the transformation to scale the paths to fit the screen
vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE);
vgLoadIdentity();
vgScale((float) m_ui32ScreenWidth, (float) m_ui32ScreenHeight);
// Reduce the stroke size to compensate for our scaling
vgSetf(VG_STROKE_LINE_WIDTH, 1.0f / m_ui32ScreenHeight);
//Create and set the clear colour
VGfloat afClearColour[] = { 0.6f, 0.8f, 1.0f, 1.0f };
vgSetfv(VG_CLEAR_COLOR, 4, afClearColour);
return true;
}
/*!****************************************************************************
@Function LoadShaders
@Output pErrorStr A string describing the error on failure
@Return bool true if no error occured
@Description Loads and compiles the shaders and links the shader programs
required for this training course
******************************************************************************/
bool OGLES3AlphaTest::LoadShaders(CPVRTString* pErrorStr)
{
/*
Load and compile the shaders from files.
Binary shaders are tried first, source shaders
are used as fallback.
*/
if (PVRTShaderLoadFromFile(
c_szVertShaderBinFile, c_szVertShaderSrcFile,
GL_VERTEX_SHADER, GL_SGX_BINARY_IMG,
&m_uiVertShader, pErrorStr) != PVR_SUCCESS)
{
return false;
}
if (PVRTShaderLoadFromFile(
c_szTexFragShaderBinFile, c_szTexFragShaderSrcFile,
GL_FRAGMENT_SHADER, GL_SGX_BINARY_IMG,
&m_uiTexFragShader, pErrorStr) != PVR_SUCCESS)
{
return false;
}
if (PVRTShaderLoadFromFile(
c_szDiscardFragShaderBinFile, c_szDiscardFragShaderSrcFile,
GL_FRAGMENT_SHADER, GL_SGX_BINARY_IMG,
&m_uiDiscardFragShader, pErrorStr) != PVR_SUCCESS)
{
return false;
}
/*
Set up and link the shader program
*/
const char* aszAttribs[] = { "inVertex", "inTexCoord" };
// Shader program for alpha blend
if (PVRTCreateProgram(&m_TexShaderProgram.uiId, m_uiVertShader, m_uiTexFragShader, aszAttribs, 2, pErrorStr) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
// Set the sampler2D variable to the first texture unit
glUniform1i(glGetUniformLocation(m_TexShaderProgram.uiId, "sTexture"), 0);
// Store the location of uniforms for later use
m_TexShaderProgram.uiMVPMatrixLoc = glGetUniformLocation(m_TexShaderProgram.uiId, "MVPMatrix");
// Shader program for alpha test
if (PVRTCreateProgram(&m_DiscardShaderProgram.uiId, m_uiVertShader, m_uiDiscardFragShader, aszAttribs, 2, pErrorStr) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
// Set the sampler2D variable to the first texture unit
glUniform1i(glGetUniformLocation(m_DiscardShaderProgram.uiId, "sTexture"), 0);
// Store the location of uniforms for later use
m_DiscardShaderProgram.uiMVPMatrixLoc = glGetUniformLocation(m_DiscardShaderProgram.uiId, "MVPMatrix");
m_DiscardShaderProgram.uiAlphaRefLoc = glGetUniformLocation(m_DiscardShaderProgram.uiId, "AlphaReference");
return true;
}
/*!****************************************************************************
@Function LoadShaders
@Output pErrorStr A string describing the error on failure
@Return bool true if no error occured
@Description Loads and compiles the shaders and links the shader programs
required for this training course
******************************************************************************/
bool OGLES3EdgeDetection::LoadShaders(CPVRTString* pErrorStr)
{
/* Load and compile the shaders from files.
Binary shaders are tried first, source shaders
are used as fallback. */
// Load vertex shaders
if (PVRTShaderLoadFromFile(
c_szPreVertShaderBin, c_szPreVertShaderSrc, GL_VERTEX_SHADER, GL_SGX_BINARY_IMG, &m_uiPreVertShader, pErrorStr) != PVR_SUCCESS)
{
*pErrorStr += "Error: Could not load Pre Process Vertex Shader.";
return false;
}
for (int i=0; i<eNumPostShaders; ++i)
{
if (PVRTShaderLoadFromFile(
c_szPostVertShaderBin, c_szPostVertShaderSrc, GL_VERTEX_SHADER, GL_SGX_BINARY_IMG, &m_uiPostVertShaders[i],
pErrorStr, 0, c_aszPostShaderDefines[i], g_auiNumPostShaderDefines[i]) != PVR_SUCCESS)
{
*pErrorStr += "Error: Could not load Post Process Vertex Shader: ";
*pErrorStr += g_aszPostShaderNames[i];
return false;
}
}
// Load fragment shaders
if (PVRTShaderLoadFromFile(
c_szPreFragShaderBin, c_szPreFragShaderSrc, GL_FRAGMENT_SHADER, GL_SGX_BINARY_IMG, &m_uiPreFragShader, pErrorStr) != PVR_SUCCESS)
{
*pErrorStr += "Error: Could not load Pre Process Fragment Shader.";
return false;
}
for (int i=0; i<eNumPostShaders; ++i)
{
if (PVRTShaderLoadFromFile(
c_szPostFragShaderBin, c_szPostFragShaderSrc, GL_FRAGMENT_SHADER, GL_SGX_BINARY_IMG, &m_uiPostFragShaders[i],
pErrorStr, 0, c_aszPostShaderDefines[i], g_auiNumPostShaderDefines[i]) != PVR_SUCCESS)
{
*pErrorStr += "Error: Could not load Post Process Vertex Shader: ";
*pErrorStr += g_aszPostShaderNames[i];
return false;
}
}
// Set up and link the shader programs
if (PVRTCreateProgram(&m_PreShader.uiId, m_uiPreVertShader, m_uiPreFragShader, g_aszAttribNames, eNumAttribs, pErrorStr) != PVR_SUCCESS)
{
*pErrorStr += "Failed to Link Pre Shader";
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
for (int i=0; i<eNumPostShaders; i++)
{
if (PVRTCreateProgram(&m_PostShaders[i].uiId, m_uiPostVertShaders[i], m_uiPostFragShaders[i], g_aszAttribNames, eNumAttribs, pErrorStr) != PVR_SUCCESS)
{
*pErrorStr += "Failed to Link Post Shader: ";
*pErrorStr += g_aszPostShaderNames[i];
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
}
// Store the location of uniforms for later use
for (int i = 0; i < eNumPreUniforms; ++i)
{
m_PreShader.auiLoc[i] = glGetUniformLocation(m_PreShader.uiId, g_aszPreUniformNames[i]);
}
for (int i = 0; i < eNumPostShaders; i++)
{
for (int j = 0; j <eNumPostUniforms; j++)
{
m_PostShaders[i].auiLoc[j] = glGetUniformLocation(m_PostShaders[i].uiId, g_aszPostUniformNames[j]);
}
//Set the post shaders to use the render texture.
glUseProgram(m_PostShaders[i].uiId);
glUniform1i(m_PostShaders[i].auiLoc[eColorBufferTexture], 1);
}
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_i32WinWidth = PVRShellGet(prefWidth);
m_i32WinHeight = PVRShellGet(prefHeight);
// Set our texture dimensions to be the same as our windows
m_i32TexWidth = m_i32WinWidth;
m_i32TexHeight = m_i32WinHeight;
/* 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_i32WinWidth,m_i32WinHeight,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);
//Initialises the time variables.
m_ulCurrentTime = PVRShellGetTime();
m_ulPreviousTimeAngle = m_ulCurrentTime;
m_ulPreviousTimeFPS = m_ulCurrentTime;
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 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 OGLES2StencilBuffer::InitView()
{
CPVRTString ErrorStr;
/*
Initialize VBO data
*/
m_Cylinder.LoadVbos();
m_Sphere.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?
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 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);
glDepthFunc(GL_LEQUAL);
// Use a nice bright blue as clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
// Set stencil clear value
glClearStencil(0);
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 OGLES2Shaders::InitView()
{
// Is the screen rotated
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
/* Initialize Print3D textures */
if (m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellOutputDebug("ERROR: Cannot initialise Print3D\n");
return false;
}
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, bRotate);
m_mView = PVRTMat4::Identity();
/*
Loads the textures.
*/
// Textures
// Get pointer to the texture name
CPVRTString ErrorStr;
char *pTexture = 0;
PVRTextureHeaderV3 Header;
for(int i = 0; i < g_numTextures; ++i)
{
if(strcmp(g_TextureList[i], "base") == 0)
pTexture = (char*) g_aszTextureNames[eTexBase];
else if(strcmp(g_TextureList[i], "reflection") == 0)
pTexture = (char*) g_aszTextureNames[eTexReflection];
else if(strcmp(g_TextureList[i], "cubemap") == 0)
pTexture = (char*) g_aszTextureNames[eTexCubeMap];
else if(strcmp(g_TextureList[i], "anisotropicmap") == 0)
pTexture = (char*) g_aszTextureNames[eTexAnisotropic];
if(PVRTTextureLoadFromPVR(pTexture, &m_puiTextureHandle[i], &Header) != PVR_SUCCESS)
{
ErrorStr = CPVRTString("ERROR: Could not open texture file ") + pTexture;
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
// Get texture flags form the header
m_uiTextureFlags[i] = (Header.u32NumFaces==6?PVRTEX_CUBEMAP:0) | (Header.u32MIPMapCount>1?PVRTEX_MIPMAP:0) | (Header.u32Depth>1?PVRTEX_VOLUME:0);
}
/*
Load the effect file
*/
for(int j = 0; j < g_numShaders; j++)
{
CPVRTString fileName;
unsigned int nUnknownUniformCount;
CPVRTString error;
/*
Parse the file
*/
m_ppEffectParser[j] = new CPVRTPFXParser();
fileName = CPVRTString(g_ShaderList[j]) + ".pfx";
if(m_ppEffectParser[j]->ParseFromFile(fileName.c_str(), &error) != PVR_SUCCESS)
{
error = CPVRTString("Parse failed for ") + fileName + ":\n\n" + error;
PVRShellSet(prefExitMessage, error.c_str());
FreeMemory();
return false;
}
/*
Load the effect from the file
*/
error = "";
m_ppEffect[j] = new CPVRTPFXEffect();
if(m_ppEffect[j]->Load(*(m_ppEffectParser[j]), "myEffect", fileName.c_str(), NULL, nUnknownUniformCount, &error) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, error.c_str());
FreeMemory();
return false;
}
if(nUnknownUniformCount)
{
error = PVRTStringFromFormattedStr("PFX File: %s\n%s Unknown uniform semantic count: %d\n", fileName.c_str(), error.c_str(), nUnknownUniformCount);
PVRShellSet(prefExitMessage, error.c_str());
FreeMemory();
return false;
}
if(!error.empty())
{
PVRShellOutputDebug(error.c_str());
}
/*
Link the textrues to the effect.
*/
const CPVRTArray<SPVRTPFXTexture>& sTex = m_ppEffect[j]->GetTextureArray();
// Loop over textures used in the CPVRTPFXEffect
for(unsigned int i = 0; i < sTex.GetSize(); ++i)
{
int iTexIdx = m_ppEffectParser[j]->FindTextureByName(sTex[i].Name);
const CPVRTStringHash& FileName = m_ppEffectParser[j]->GetTexture(iTexIdx)->FileName;
int k;
// Loop over available textures
for( k = 0; k < g_numTextures; k++)
{
CPVRTString texName;
texName = CPVRTString(g_TextureList[k]) + ".pvr";
if(FileName == texName)
{
// Set the current texture
if((m_uiTextureFlags[k] & CUBEMAP_FLAG) != 0)
glBindTexture(GL_TEXTURE_CUBE_MAP, m_puiTextureHandle[k]);
else
glBindTexture(GL_TEXTURE_2D, m_puiTextureHandle[k]);
// Link the texture to the CPVRTPFXEffect and apply filtering
m_ppEffect[j]->SetTexture(i, m_puiTextureHandle[k], m_uiTextureFlags[k]);
break;
}
}
if(k == g_numTextures)
{
// Texture not found
PVRShellOutputDebug("Warning: effect file requested unrecognised texture: \"%s\"\n", FileName.c_str());
m_ppEffect[j]->SetTexture(i, 0);
}
}
}
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
// Create the surface
m_Surface = new ParametricSurface(50,50);
ComputeSurface(m_nCurrentSurface);
return true;
}
/*******************************************************************************
* Function Name : InitApplication
* Inputs : argc, *argv[], uWidth, uHeight
* Returns : true if no error occured
* Description : Code in InitApplication() will be called by the Shell ONCE per
* run, early on in the execution of the program.
* Used to initialise variables that are not dependent on the
* rendering context (e.g. external modules, loading meshes, etc.)
*******************************************************************************/
bool CStrokeStyles::InitApplication()
{
// This sets up PVRShell to use an OpenVG context
PVRShellSet(prefOpenVGContext, true);
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 Name : InitApplication
* Returns : true if no error occured
* Description : Code in InitApplication() will be called by the Shell ONCE per
* run, early on in the execution of the program.
* Used to initialise variables that are not dependent on the
* rendering context (e.g. external modules, loading meshes, etc.)
*******************************************************************************/
bool OVGMaskLayer::InitApplication()
{
// This sets up PVRShell to use an OpenVG context
PVRShellSet(prefOpenVGContext, true);
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;
}
/*!****************************************************************************
@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 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 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 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 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 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 OGLESIntroducingPFX::InitView()
{
/*
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 depth test using the z-buffer
glEnable(GL_DEPTH_TEST);
/*
Loads the light direction from the scene.
*/
// We check the scene contains at least one
if (m_Scene.nNumLight == 0)
{
PVRShellSet(prefExitMessage, "ERROR: The scene does not contain a light\n");
return false;
}
/*
Load the effect file
*/
{
unsigned int nUnknownUniformCount;
CPVRTString error;
// Parse the file
m_pEffectParser = new CPVRTPFXParser;
if(m_pEffectParser->ParseFromFile(c_szPfxFile, &error) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, error.c_str());
return false;
}
// Load an effect from the file
m_pEffect = new CPVRTPFXEffect();
if(m_pEffect->Load(*m_pEffectParser, "Effect", c_szPfxFile, &error) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, error.c_str());
return false;
}
// Generate uniform array
if(m_pEffect->BuildUniformTable(
&m_psUniforms, &m_nUniformCnt, &nUnknownUniformCount,
c_psUniformSemantics, sizeof(c_psUniformSemantics) / sizeof(*c_psUniformSemantics),
&error) != PVR_SUCCESS)
{
PVRShellOutputDebug(error.c_str());
return false;
}
if(nUnknownUniformCount)
{
PVRShellOutputDebug(error.c_str());
PVRShellOutputDebug("Unknown uniform semantic count: %d\n", nUnknownUniformCount);
}
}
/*
Loads the textures.
For a more detailed explanation, see Texturing and IntroducingPVRTools
*/
{
const SPVRTPFXTexture *psTex;
unsigned int nCnt, i;
GLuint ui;
psTex = m_pEffect->GetTextureArray(nCnt);
for(i = 0; i < nCnt; ++i)
{
if(strcmp(psTex[i].p, "Reflection.pvr") == 0)
{
if(PVRTTextureLoadFromPVR(c_szReflectTexFile, &ui) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot load the texture\n");
return false;
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
m_pEffect->SetTexture(i, ui);
}
else if (strcmp(psTex[i].p, "Basetex.pvr") == 0)
{
if(PVRTTextureLoadFromPVR(c_szBaseTexFile, &ui) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot load the texture\n");
return false;
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
m_pEffect->SetTexture(i, ui);
}
else
{
PVRShellOutputDebug("Warning: effect file requested unrecognised texture: \"%s\"\n", psTex[i].p);
m_pEffect->SetTexture(i, 0);
}
}
}
// Create buffer objects.
m_aiVboID = new GLuint[m_Scene.nNumMeshNode];
glGenBuffers(m_Scene.nNumMeshNode, m_aiVboID);
for(int i = 0; i < (int)m_Scene.nNumMeshNode ; i++)
{
SPODNode* pNode = &m_Scene.pNode[i];
// Gets pMesh referenced by the pNode
SPODMesh* pMesh = &m_Scene.pMesh[pNode->nIdx];
// Generate a vertex buffer and set the interleaved vertex data.
glBindBuffer(GL_ARRAY_BUFFER, m_aiVboID[i]);
glBufferData(GL_ARRAY_BUFFER, pMesh->sVertex.nStride*pMesh->nNumVertex, pMesh->pInterleaved, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
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 OGLES3Skybox2::InitView()
{
// Sets the clear colour
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
// Enables depth test using the z-buffer
glEnable(GL_DEPTH_TEST);
CPVRTString ErrorStr;
/*
Load textures
*/
if(!LoadTextures(&ErrorStr))
{
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
/*********************/
/* Create the Skybox */
/*********************/
float* skyboxVertices;
float* skyboxUVs;
PVRTCreateSkybox( 500.0f, true, 512, &skyboxVertices, &skyboxUVs );
glGenBuffers(1, &m_iSkyVboID);
glBindBuffer(GL_ARRAY_BUFFER, m_iSkyVboID);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * 24, &skyboxVertices[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
PVRTDestroySkybox(skyboxVertices, skyboxUVs);
/**********************/
/* Create the Effects */
/**********************/
{
// Parse the file
m_pEffectParser = new CPVRTPFXParser();
if(m_pEffectParser->ParseFromFile(g_pszEffectFileName, &ErrorStr) != PVR_SUCCESS)
{
delete m_pEffectParser;
PVRShellSet(prefExitMessage, ErrorStr.c_str());
return false;
}
m_ppEffects = new CPVRTPFXEffect*[g_ui32NoOfEffects];
memset(m_ppEffects, 0, sizeof(CPVRTPFXEffect*) * g_ui32NoOfEffects);
// Skybox shader
if(!LoadEffect(&m_ppEffects[0], "skybox_effect", g_pszEffectFileName))
{
delete m_pEffectParser;
delete[] m_ppEffects;
return false;
}
// The Balloon Shaders
if(!LoadEffect(&m_ppEffects[1], "balloon_effect1", g_pszEffectFileName) ||
!LoadEffect(&m_ppEffects[2], "balloon_effect2", g_pszEffectFileName) ||
!LoadEffect(&m_ppEffects[3], "balloon_effect3", g_pszEffectFileName) ||
!LoadEffect(&m_ppEffects[4], "balloon_effect4", g_pszEffectFileName) ||
!LoadEffect(&m_ppEffects[5], "balloon_effect5", g_pszEffectFileName) ||
!LoadEffect(&m_ppEffects[6], "balloon_effect6", g_pszEffectFileName) ||
!LoadEffect(&m_ppEffects[7], "balloon_effect7", g_pszEffectFileName))
{
delete m_pEffectParser;
delete[] m_ppEffects;
return false;
}
}
// Create Geometry Buffer Objects.
m_aiVboID = new GLuint[m_Scene.nNumMeshNode];
glGenBuffers(m_Scene.nNumMeshNode, m_aiVboID);
for(unsigned int i = 0; i < m_Scene.nNumMeshNode ; ++i)
{
SPODNode* pNode = &m_Scene.pNode[i];
// Gets pMesh referenced by the pNode
SPODMesh* pMesh = &m_Scene.pMesh[pNode->nIdx];
// Genereta a vertex buffer and set the interleaved vertex datas.
glBindBuffer(GL_ARRAY_BUFFER, m_aiVboID[i]);
glBufferData(GL_ARRAY_BUFFER, pMesh->sVertex.nStride*pMesh->nNumVertex, pMesh->pInterleaved, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
/**********************
** Projection Matrix **
**********************/
/* Projection */
bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen);
m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI / 6, (float) PVRShellGet(prefWidth) / (float) PVRShellGet(prefHeight), 4.0f, 1000.0f, PVRTMat4::OGL, bRotate);
// Calculate the model view matrix turning around the balloon
ComputeViewMatrix();
/* Init Values */
bPause = false;
fDemoFrame = 0.0;
fBurnAnim = 0.0f;
m_i32Effect = 1;
// Initialise Print3D
if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n");
return false;
}
// 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 OGLES3Texturing::InitView()
{
// Fragment and vertex shaders code
const char* pszFragShader = "\
#version 300 es\n\
uniform sampler2D sampler2d;\
in mediump vec2 myTexCoord;\
layout (location = 0) out lowp vec4 oColour;\
void main (void)\
{\
oColour = texture(sampler2d,myTexCoord);\
}";
const char* pszVertShader = "\
#version 300 es\n\
#define VERTEX_ARRAY 0\n\
#define TEXCOORD_ARRAY 1\n\
layout (location = VERTEX_ARRAY) in highp vec4 myVertex;\
layout (location = TEXCOORD_ARRAY) in highp vec2 myUV;\
uniform mediump mat4 myPMVMatrix;\
out mediump vec2 myTexCoord;\
void main(void)\
{\
gl_Position = myPMVMatrix * myVertex;\
myTexCoord = myUV;\
}";
// Create the fragment shader object
m_uiFragShader = glCreateShader(GL_FRAGMENT_SHADER);
// Load the source code into it
glShaderSource(m_uiFragShader, 1, (const char**)&pszFragShader, NULL);
// Compile the source code
glCompileShader(m_uiFragShader);
// Check if compilation succeeded
GLint bShaderCompiled;
glGetShaderiv(m_uiFragShader, GL_COMPILE_STATUS, &bShaderCompiled);
if (!bShaderCompiled)
{
// An error happened, first retrieve the length of the log message
int i32InfoLogLength, i32CharsWritten;
glGetShaderiv(m_uiFragShader, GL_INFO_LOG_LENGTH, &i32InfoLogLength);
// Allocate enough space for the message and retrieve it
char* pszInfoLog = new char[i32InfoLogLength];
glGetShaderInfoLog(m_uiFragShader, i32InfoLogLength, &i32CharsWritten, pszInfoLog);
/*
Displays the message in a dialog box when the application quits
using the shell PVRShellSet function with first parameter prefExitMessage.
*/
char* pszMsg = new char[i32InfoLogLength+256];
strcpy(pszMsg, "Failed to compile fragment shader: ");
strcat(pszMsg, pszInfoLog);
PVRShellSet(prefExitMessage, pszMsg);
delete [] pszMsg;
delete [] pszInfoLog;
return false;
}
// Loads the vertex shader in the same way
m_uiVertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(m_uiVertexShader, 1, (const char**)&pszVertShader, NULL);
glCompileShader(m_uiVertexShader);
glGetShaderiv(m_uiVertexShader, GL_COMPILE_STATUS, &bShaderCompiled);
if (!bShaderCompiled)
{
int i32InfoLogLength, i32CharsWritten;
glGetShaderiv(m_uiVertexShader, GL_INFO_LOG_LENGTH, &i32InfoLogLength);
char* pszInfoLog = new char[i32InfoLogLength];
glGetShaderInfoLog(m_uiVertexShader, i32InfoLogLength, &i32CharsWritten, pszInfoLog);
char* pszMsg = new char[i32InfoLogLength+256];
strcpy(pszMsg, "Failed to compile vertex shader: ");
strcat(pszMsg, pszInfoLog);
PVRShellSet(prefExitMessage, pszMsg);
delete [] pszMsg;
delete [] pszInfoLog;
return false;
}
// Create the shader program
m_uiProgramObject = glCreateProgram();
// Attach the fragment and vertex shaders to it
glAttachShader(m_uiProgramObject, m_uiFragShader);
glAttachShader(m_uiProgramObject, m_uiVertexShader);
// Bind the custom vertex attribute "myVertex" to location VERTEX_ARRAY
glBindAttribLocation(m_uiProgramObject, VERTEX_ARRAY, "myVertex");
// Bind the custom vertex attribute "myUV" to location TEXCOORD_ARRAY
glBindAttribLocation(m_uiProgramObject, TEXCOORD_ARRAY, "myUV");
// Link the program
glLinkProgram(m_uiProgramObject);
// Check if linking succeeded in the same way we checked for compilation success
GLint bLinked;
glGetProgramiv(m_uiProgramObject, GL_LINK_STATUS, &bLinked);
if (!bLinked)
{
int i32InfoLogLength, i32CharsWritten;
glGetProgramiv(m_uiProgramObject, GL_INFO_LOG_LENGTH, &i32InfoLogLength);
char* pszInfoLog = new char[i32InfoLogLength];
glGetProgramInfoLog(m_uiProgramObject, i32InfoLogLength, &i32CharsWritten, pszInfoLog);
char* pszMsg = new char[i32InfoLogLength+256];
strcpy(pszMsg, "Failed to link program: ");
strcat(pszMsg, pszInfoLog);
PVRShellSet(prefExitMessage, pszMsg);
delete [] pszMsg;
delete [] pszInfoLog;
return false;
}
// Actually use the created program
glUseProgram(m_uiProgramObject);
// Sets the sampler2D variable to the first texture unit
glUniform1i(glGetUniformLocation(m_uiProgramObject, "sampler2d"), 0);
// Sets the clear color
glClearColor(0.6f, 0.8f, 1.0f, 1.0f);
/*
Creates the texture
*/
// Allocates one texture handle
glGenTextures(1, &m_uiTexture);
// Binds this texture handle so we can load the data into it
glBindTexture(GL_TEXTURE_2D, m_uiTexture);
// Creates the data as a 32bits integer array (8bits per component)
GLuint* pTexData = new GLuint[TEX_SIZE*TEX_SIZE];
for (int i=0; i<TEX_SIZE; i++)
for (int j=0; j<TEX_SIZE; j++)
{
// Fills the data with a fancy pattern
GLuint col = (255<<24) + ((255-j*2)<<16) + ((255-i)<<8) + (255-i*2);
if ( ((i*j)/8) % 2 ) col = (GLuint) (255<<24) + (255<<16) + (0<<8) + (255);
pTexData[j*TEX_SIZE+i] = col;
}
/*
glTexImage2D loads the texture data into the texture object.
void glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type, const GLvoid *pixels );
target must be GL_TEXTURE_2D.
level specify the mipmap level we want to upload.
internalformat and format must be the same. Here we use GL_RGBA for 4 component colors (r,g,b,a).
We could use GL_RGB, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA to use different color component combinations.
width, height specify the size of the texture. Both of the dimensions must be power of 2.
border must be 0.
type specify the format of the data. We use GL_UNSIGNED_BYTE to describe a color component as an unsigned byte.
So a pixel is described by a 32bits integer.
We could also use GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_4_4_4_4, and GL_UNSIGNED_SHORT_5_5_5_1
to specify the size of all 3 (or 4) color components. If we used any of these 3 constants,
a pixel would then be described by a 16bits integer.
*/
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_SIZE, TEX_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, pTexData);
/*
glTexParameterf is used to set the texture parameters
void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
target must be GL_TEXTURE_2D.
pname is the parameter name we want to modify.
If pname is GL_TEXTURE_MIN_FILTER, param is used to set the way the texture is rendered when made smaller.
We can tell OpenGL to interpolate between the pixels in a mipmap level but also between different mipmap levels.
We are not using mipmap interpolation here because we didn't defined the mipmap levels of our texture.
If pname is GL_TEXTURE_MAG_FILTER, param is used to set the way the texture is rendered when made bigger.
Here we can only tell OpenGL to interpolate between the pixels of the first mipmap level.
if pname is GL_TEXTURE_WRAP_S or GL_TEXTURE_WRAP_T, then param sets the way a texture tiles in both directions.
The default if GL_REPEAT to wrap the texture (repeat it). We could also set it to GL_CLAMP or GL_CLAMP_TO_EDGE
to clamp the texture.
On OpenGL ES 1.1 and 2.0, if pname is GL_GENERATE_MIPMAP, param tells OpenGL to create mipmap levels automatically.
*/
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
// Deletes the texture data, it's now in OpenGL memory
delete [] pTexData;
// Create VBO for the triangle from our data
// Interleaved vertex data
GLfloat afVertices[] = {-0.4f,-0.4f,0.0f, // Pos
0.0f,0.0f , // UVs
0.4f,-0.4f,0.0f,
1.0f,0.0f ,
0.0f,0.4f ,0.0f,
0.5f,1.0f
};
glGenBuffers(1, &m_ui32Vbo);
m_ui32VertexStride = 5 * sizeof(GLfloat); // 3 floats for the pos, 2 for the UVs
// Bind the VBO
glBindBuffer(GL_ARRAY_BUFFER, m_ui32Vbo);
// Set the buffer's data
glBufferData(GL_ARRAY_BUFFER, 3 * m_ui32VertexStride, afVertices, GL_STATIC_DRAW);
// Unbind the VBO
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Enable culling
glEnable(GL_CULL_FACE);
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 LoadShaders
@Output pErrorStr A string describing the error on failure
@Return bool true if no error occured
@Description Loads and compiles the shaders and links the shader programs
required for this training course
******************************************************************************/
bool OGLES2ShadowMapping::LoadShaders(CPVRTString* pErrorStr)
{
const char* aszAttribs[] = { "inVertex", "inNormal", "inTexCoord" };
/*
Load and compile the shaders from files.
Binary shaders are tried first, source shaders
are used as fallback.
*/
if(PVRTShaderLoadFromFile(
c_szVertShaderBinFile, c_szVertShaderSrcFile, GL_VERTEX_SHADER, GL_SGX_BINARY_IMG, &m_uiSimpleVertShader, pErrorStr) != PVR_SUCCESS)
{
return false;
}
if(PVRTShaderLoadFromFile(
c_szFragShaderBinFile, c_szFragShaderSrcFile, GL_FRAGMENT_SHADER, GL_SGX_BINARY_IMG, &m_uiSimpleFragShader, pErrorStr) != PVR_SUCCESS)
{
return false;
}
if(PVRTCreateProgram(&m_SimpleShaderProgram.uiId, m_uiSimpleVertShader, m_uiSimpleFragShader, 0, 0, pErrorStr) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
m_SimpleShaderProgram.uiModelViewMatrixLoc = glGetUniformLocation(m_SimpleShaderProgram.uiId, "ModelViewMatrix");
m_SimpleShaderProgram.uiProjectionMatrixLoc = glGetUniformLocation(m_SimpleShaderProgram.uiId, "ProjectionMatrix");
if(PVRTCreateProgram(&m_SimpleShaderProgram.uiId, m_uiSimpleVertShader, m_uiSimpleFragShader, aszAttribs, 3, pErrorStr) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
if(PVRTShaderLoadFromFile(
c_szShadowMapppingVertBinFile, c_szShadowMapppingVertSrcFile, GL_VERTEX_SHADER, GL_SGX_BINARY_IMG, &m_uiShadowVertShader, pErrorStr) != PVR_SUCCESS)
{
return false;
}
if(PVRTShaderLoadFromFile(
c_szShadowMapppingFragBinFile, c_szShadowMapppingFragSrcFile, GL_FRAGMENT_SHADER, GL_SGX_BINARY_IMG, &m_uiShadowFragShader, pErrorStr) != PVR_SUCCESS)
{
return false;
}
if(PVRTCreateProgram(&m_ShadowShaderProgram.uiId, m_uiShadowVertShader, m_uiShadowFragShader, 0, 0, pErrorStr) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
m_ShadowShaderProgram.uiTexProjMatrixLoc = glGetUniformLocation(m_ShadowShaderProgram.uiId, "TexProjectionMatrix");
m_ShadowShaderProgram.uiModelViewMatrixLoc = glGetUniformLocation(m_ShadowShaderProgram.uiId, "ModelViewMatrix");
m_ShadowShaderProgram.uiProjectionMatrixLoc = glGetUniformLocation(m_ShadowShaderProgram.uiId, "ProjectionMatrix");
m_ShadowShaderProgram.uiLightDirLoc = glGetUniformLocation(m_ShadowShaderProgram.uiId, "LightDirection");
if(PVRTCreateProgram(&m_ShadowShaderProgram.uiId, m_uiShadowVertShader, m_uiShadowFragShader, aszAttribs, 3, pErrorStr) != PVR_SUCCESS)
{
PVRShellSet(prefExitMessage, pErrorStr->c_str());
return false;
}
glUniform1i(glGetUniformLocation(m_ShadowShaderProgram.uiId, "sShadow"), 0);
glUniform1i(glGetUniformLocation(m_ShadowShaderProgram.uiId, "sTexture"), 1);
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 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;
}
