//--------------------------------------------------------------------------------------
// Name: CSample()
// Desc: Constructor
//--------------------------------------------------------------------------------------
CSample::CSample( const CHAR* strName ) : CFrmApplication( strName )
{
m_nCurShaderIndex = 0;
m_hOverlayShader = 0;
m_hDepthShader = 0;
m_hDepthMVPLoc = 0;
m_pLogoTexture = NULL;
m_nCurMeshIndex = 0;
m_hDiffuseSpecularTexId = 0;
m_hDiffuseSpecularBufId = 0;
m_hDiffuseSpecularDepthBufId = 0;
m_SkyColor = FRMVECTOR3(0.9f, 0.1f, 0.1f);
m_GroundColor = FRMVECTOR3(0.1f, 0.1f, 0.1f);
m_MaterialSpecular = FRMVECTOR3(0.6f, 0.5f, 0.5f);
m_MaterialDiffuse = FRMVECTOR3(0.9f, 0.3f, 0.3f);
m_LightColor = FRMVECTOR3(0.9f, 0.9f, 0.9f);
m_MaterialGlossiness = 0.4f;
m_OpenGLESVersion = GLES3;
}
//--------------------------------------------------------------------------------------
// Name: Resize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Resize()
{
FLOAT32 fAspect = (FLOAT32)m_nWidth / (FLOAT32)m_nHeight;
m_matProj = FrmMatrixPerspectiveFovRH( FRM_PI/4.0f, fAspect, 1.0f, 1000.0f );
// To keep sizes consistent, scale the projection matrix in landscape oriention
if( fAspect > 1.0f )
{
m_matProj.M(0,0) *= fAspect;
m_matProj.M(1,1) *= fAspect;
}
// Initialize the viewport
FRMMATRIX4X4 m_matView;
FRMVECTOR3 vPosition = FRMVECTOR3( 0.0f, 0.0f, 5.0f );
FRMVECTOR3 vLookAt = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
FRMVECTOR3 vUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_matView = FrmMatrixLookAtRH( vPosition, vLookAt, vUp );
m_matProj = FrmMatrixMultiply( m_matView, m_matProj );
// Initialize the viewport
glViewport( 0, 0, m_nWidth, m_nHeight );
return TRUE;
}
FLOAT32 CFrmPerlin::Noise3( const FLOAT32 x, const FLOAT32 y, const FLOAT32 z )
{
setup(x, bx0, bx1, rx0, rx1);
setup(y, by0, by1, ry0, ry1);
setup(z, bz0, bz1, rz0, rz1);
INT32 b00 = m_p[m_p[bx0] + by0];
INT32 b10 = m_p[m_p[bx1] + by0];
INT32 b01 = m_p[m_p[bx0] + by1];
INT32 b11 = m_p[m_p[bx1] + by1];
FLOAT32 sx = FrmSCurve(rx0);
FLOAT32 sy = FrmSCurve(ry0);
FLOAT32 sz = FrmSCurve(rz0);
FLOAT32 a0 = FrmLerp(sx, FrmVector3Dot(m_g3[b00 + bz0], FRMVECTOR3(rx0, ry0, rz0)), FrmVector3Dot(m_g3[b10 + bz0], FRMVECTOR3(rx1, ry0, rz0)));
FLOAT32 b0 = FrmLerp(sx, FrmVector3Dot(m_g3[b01 + bz0], FRMVECTOR3(rx0, ry1, rz0)), FrmVector3Dot(m_g3[b11 + bz0], FRMVECTOR3(rx1, ry1, rz0)));
FLOAT32 c0 = FrmLerp(sy, a0, b0);
FLOAT32 a1 = FrmLerp(sx, FrmVector3Dot(m_g3[b00 + bz1], FRMVECTOR3(rx0, ry0, rz1)), FrmVector3Dot(m_g3[b10 + bz1], FRMVECTOR3(rx1, ry0, rz1)));
FLOAT32 b1 = FrmLerp(sx, FrmVector3Dot(m_g3[b01 + bz1], FRMVECTOR3(rx0, ry1, rz1)), FrmVector3Dot(m_g3[b11 + bz1], FRMVECTOR3(rx1, ry1, rz1)));
FLOAT32 c1 = FrmLerp(sy, a1, b1);
return FrmLerp(sz, c0, c1);
}
//--------------------------------------------------------------------------------------
// Name: InitParticles()
// Desc: Initializes the particles
//--------------------------------------------------------------------------------------
static VOID InitParticles( PARTICLE* pParticles, GLuint *pParticleBuffers, GLuint *pParticleVAOs, GLuint *pQuery)
{
for( UINT32 i = 0; i < NUM_PARTICLES; i++ )
{
pParticles[i].m_vPosition = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
pParticles[i].m_vVelocity = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
pParticles[i].m_vColor = FRMVECTOR4( 1.0, 0.0, 0.0, 0.0 );
pParticles[i].m_fInitialSize = 0.0f;
pParticles[i].m_fSizeIncreaseRate = 0.0f;
pParticles[i].m_fStartTime = 0.0f;
pParticles[i].m_fLifeSpan = -1.0f;
}
glGenQueries(1, pQuery);
glGenVertexArrays(2, pParticleVAOs);
// Create and initialize both Particle buffers to this particle data
glGenBuffers(2, pParticleBuffers );
glBindBuffer( GL_ARRAY_BUFFER, pParticleBuffers[0] );
glBufferData( GL_ARRAY_BUFFER, sizeof(PARTICLE)*NUM_PARTICLES, pParticles, GL_STREAM_DRAW );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glBindBuffer( GL_ARRAY_BUFFER, pParticleBuffers[1] );
glBufferData( GL_ARRAY_BUFFER, sizeof(PARTICLE)*NUM_PARTICLES, pParticles, GL_STREAM_DRAW );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
//--------------------------------------------------------------------------------------
// Name: CSample()
// Desc: Constructor
//--------------------------------------------------------------------------------------
CSample::CSample( const CHAR* strName ) : CFrmApplication( strName )
{
m_pModel = NULL;
m_pAnim = NULL;
m_hSkinningShader = 0;
m_pLogoTexture = NULL;
m_pModelTexture = NULL;
m_hVertexBuffer = NULL;
m_hIndexBuffer = NULL;
m_vertexFormatMap = NULL;
m_cameraPosition = FRMVECTOR3( 10.0f, 15.0f, 25.0f );
m_cameraLookAt = FRMVECTOR3( 0.0f, 5.0f, 0.0f );
m_cameraUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_lightPosition = FRMVECTOR3( 50.0f, 50.0f, 50.0f );
m_curAnimFrame = 0;
m_lastAnimFrame = 0;
m_frameWeight = 1.0f;
m_animStartIndex = 0;
m_animLength = 0;
m_speedFactor = 1.0f;
}
//--------------------------------------------------------------------------------------
// Name: Update()
// Desc:
//--------------------------------------------------------------------------------------
VOID CSample22::Update()
{
// get the current time
FLOAT32 ElapsedTime = m_Timer.GetFrameElapsedTime();
// process input
UINT32 nButtons;
UINT32 nPressedButtons;
FrmGetInput( &m_Input, &nButtons, &nPressedButtons );
// toggle user interface
if( nPressedButtons & INPUT_KEY_0 )
m_UserInterface.AdvanceState();
// toggle rotation
if( nPressedButtons & INPUT_KEY_8 )
{
m_ShouldRotate = 1 - m_ShouldRotate;
}
if( nPressedButtons & INPUT_KEY_4 )
{
EyeColor--;
if( EyeColor < 0 )
EyeColor = EYE_COLORS - 1;
}
if( nPressedButtons & INPUT_KEY_5 )
{
EyeColor++;
if( EyeColor >= EYE_COLORS )
EyeColor = 0;
}
if( nButtons & INPUT_KEY_6 )
{
m_Object.IrisGlow -= 4.0f * ElapsedTime;
m_Object.IrisGlow = max( 0.0f, m_Object.IrisGlow );
}
if( nButtons & INPUT_KEY_7 )
{
m_Object.IrisGlow += 4.0f * ElapsedTime;
m_Object.IrisGlow = min( 8.0f, m_Object.IrisGlow );
}
// update light position
m_LightPos = FRMVECTOR3( -4.0f, 10.0f, 10.0f );
// build camera transforms
FRMVECTOR3 LookDir = FRMVECTOR3( 0.0f, 0.0f, -1.0f );
FRMVECTOR3 UpDir = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
FRMVECTOR3 Temp = m_CameraPos + LookDir;
m_matView = FrmMatrixLookAtRH( m_CameraPos, Temp, UpDir );
m_matViewProj = FrmMatrixMultiply( m_matView, m_matProj );
// update objects
m_Object.Update( ElapsedTime, m_ShouldRotate );
}
//--------------------------------------------------------------------------------------
// Name: DrawMeshVectors()
// Desc: Visualizes the mesh vectors using the supplied ModelViewProj matrix
//--------------------------------------------------------------------------------------
VOID CFrmShowMeshVectors::DrawMeshVectors( FRMMATRIX4X4 matMVP, FLOAT32 fLength )
{
glUseProgram( m_hShowNormalsShader );
glUniformMatrix4fv( glGetUniformLocation( m_hShowNormalsShader, "g_matModelViewProj" ),
1, FALSE, (FLOAT32*)&matMVP );
glUniform1f( glGetUniformLocation( m_hShowNormalsShader, "g_fMaxExtrusion" ), fLength );
if( m_vNormals ) DrawVectors( m_vNormals, FRMVECTOR3( 1.0f, 0.0f, 0.0f ) );
if( m_vTangents ) DrawVectors( m_vTangents, FRMVECTOR3( 0.0f, 1.0f, 0.0f ) );
if( m_vBinormals ) DrawVectors( m_vBinormals, FRMVECTOR3( 0.0f, 0.0f, 1.0f ) );
}
//--------------------------------------------------------------------------------------
// Name: RenderCube()
// Desc:
//--------------------------------------------------------------------------------------
VOID CSample::RenderCube()
{
FLOAT32 fPrevFrameTime = m_fCurrentTime;
m_fCurrentTime = FrmGetTime();
// Rotate the object
m_fRotTotal += m_fSpeed * ( m_fCurrentTime - fPrevFrameTime );
FRMMATRIX4X4 matTrans1 = FrmMatrixTranslate( 0.0f, 0.6f * FrmSin( m_fRotTotal * 2.0f ), 0.0f );
FRMVECTOR3 vTmp;
vTmp = FRMVECTOR3(0.0f, 0.0f, 1.0f);
FRMMATRIX4X4 matRotate1 = FrmMatrixRotate( m_fRotTotal * 1.0f, vTmp );
vTmp = FRMVECTOR3(1.0f, 0.0f, 0.0f);
FRMMATRIX4X4 matRotate2 = FrmMatrixRotate( m_fRotTotal * 3.0f, vTmp );
vTmp = FRMVECTOR3(0.0f, 1.0f, 0.0f);
FRMMATRIX4X4 matRotate3 = FrmMatrixRotate( m_fRotTotal * 1.5f, vTmp );
vTmp = FRMVECTOR3(1.0f, 0.0f, 1.0f);
FRMMATRIX4X4 matRotate4 = FrmMatrixRotate( m_fRotTotal * -1.0f, vTmp );
FRMMATRIX4X4 matModel = FrmMatrixMultiply( matRotate4, matTrans1 );
matModel = FrmMatrixMultiply( matRotate3, matModel );
matModel = FrmMatrixMultiply( matRotate2, matModel );
matModel = FrmMatrixMultiply( matRotate1, matModel );
FRMMATRIX4X4 matModelView = FrmMatrixMultiply( matModel, m_matView );
m_matModelViewProj = FrmMatrixMultiply( matModelView, m_mPerspectiveMatrix );
glEnable( GL_DEPTH_TEST );
glUseProgram( m_hConstantShader );
glUniformMatrix4fv( m_nConstantMVPSlot, 1, FALSE, (FLOAT32*)&m_matModelViewProj );
glVertexAttribPointer( 0, 3, GL_FLOAT, 0, 0, g_pCube );
glEnableVertexAttribArray( 0 );
glVertexAttribPointer( 1, 4, GL_FLOAT, 0, 0, g_pColor );
glEnableVertexAttribArray( 1 );
glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
glDrawArrays( GL_TRIANGLE_STRIP, 4, 4 );
glDrawArrays( GL_TRIANGLE_STRIP, 8, 4 );
glDrawArrays( GL_TRIANGLE_STRIP, 12, 4 );
glDrawArrays( GL_TRIANGLE_STRIP, 16, 4 );
glDrawArrays( GL_TRIANGLE_STRIP, 20, 4 );
glDisableVertexAttribArray( 1 );
glDisableVertexAttribArray( 0 );
glDisable( GL_DEPTH_TEST );
}
//--------------------------------------------------------------------------------------
// Name:
// Desc:
//--------------------------------------------------------------------------------------
CFrmPerlin::CFrmPerlin()
{
for( INT32 i = 0; i < B; i++ )
{
m_p[i] = i;
m_g1[i] = RAND / B;
FRMVECTOR2 v2Rand = (FRMVECTOR2(RAND, RAND) / B);
m_g2[i] = FrmVector2Normalize(v2Rand);
FRMVECTOR3 v3Rand = (FRMVECTOR3(RAND, RAND, RAND) / B);
m_g3[i] = FrmVector3Normalize(v3Rand);
}
for( INT32 i = 0; i < B; i++ )
{
INT32 r = rand() % B;
INT32 tmp = m_p[i];
m_p[i] = m_p[r];
m_p[r] = tmp;
}
for( INT32 i = 0; i < B + 2; i++ )
{
m_p[B + i] = m_p[i];
m_g1[B + i] = m_g1[i];
m_g2[B + i] = m_g2[i];
m_g3[B + i] = m_g3[i];
}
}
//--------------------------------------------------------------------------------------
// Name: Resize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Resize()
{
FLOAT32 fAspect = (FLOAT32)m_nWidth / (FLOAT32)m_nHeight;
m_mPerspectiveMatrix = FrmMatrixPerspectiveFovRH( FRM_PI/4.0f, fAspect, 1.0f, 100.0f );
// To keep sizes consistent, scale the projection matrix in landscape oriention
if( fAspect > 1.0f )
{
m_mPerspectiveMatrix.M(0,0) *= fAspect;
m_mPerspectiveMatrix.M(1,1) *= fAspect;
// Rotate the cube to better use the space
FRMVECTOR3 vZ = FRMVECTOR3(0.0f, 0.0f, 1.0f);
FRMMATRIX4X4 mRotate = FrmMatrixRotate( FRM_PI/2, vZ );
m_mPerspectiveMatrix = FrmMatrixMultiply( mRotate, m_mPerspectiveMatrix );
}
// Initialize the viewport
glViewport( 0, 0, m_nWidth, m_nHeight );
// Create the motion blur class
delete m_pMotionBlur;
m_pMotionBlur = new CMotionBlur( m_hTextureShader, m_nTextureAlphaSlot,
WrapperRenderBlurredScene, this, m_fShutterDuration,
m_nWidth, m_nHeight, m_nFBOTextureWidth, m_nFBOTextureHeight );
return TRUE;
}
//--------------------------------------------------------------------------------------
// Name:
// Desc:
//--------------------------------------------------------------------------------------
SimpleObject42::SimpleObject42()
{
ModelScale = 1.0f;
Position = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
RotateTime = 0.0f;
Drawable = NULL;
BumpTexture = NULL;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample31::Initialize(CFrmFontGLES &m_Font, CFrmTexture* m_pLogoTexture)
{
m_ShouldRotate = TRUE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Demos/AdrenoShaders/Textures/31_Textures.pak" ) )
return FALSE;
// Create textures
m_GodRayTexture = resource.GetTexture( "GodRay1" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5, m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( (char *)"Press \200 for Help", 1.0f, -1.0f );
m_UserInterface.AddBoolVariable( &m_ShouldRotate, (char *)"Should Rotate" );
m_UserInterface.AddFloatVariable( &m_RayExtruderShader.RayLength, (char *)"Ray length" );
m_UserInterface.AddFloatVariable( &m_CutoutShader.OccluderThreshold, (char *)"Occluder pickup distance" );
m_UserInterface.AddFloatVariable( &m_CutoutShader.OccluderFadeout, (char *)"Occluder fade distance" );
m_UserInterface.AddFloatVariable( &m_CombineShader.RayOpacity, (char *)"Ray opacity" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, (char *)"Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, (char *)"Decrease ray length" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, (char *)"Increase ray length" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, (char *)"Decrease pickup dist" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, (char *)"Increase pickup dist" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_5, (char *)"Decrease pickup fade" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_6, (char *)"Increase pickup fade" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_7, (char *)"Decrease opacity" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_8, (char *)"Increase opacity" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_9, (char *)"Toggle Rotation" );
// Load the mesh
if( FALSE == m_Mesh.Load( "Demos/AdrenoShaders/Meshes/Map3.mesh" ) )
return FALSE;
m_CameraPos = FRMVECTOR3( 6.2f, 2.0f, 0.0f );
float Split = 1.1f;
float yAdjust = -0.05f;
ModelScale31 = 1.0f;
if( FALSE == m_Mesh.MakeDrawable( &resource ) )
return FALSE;
// Initialize the shaders
if( FALSE == InitShaders() )
{
return FALSE;
}
m_AmbientLight = FRMVECTOR4( 0.05f, 0.05f, 0.05f, 0.0f );
// Set up the objects
m_Object.Drawable = &m_Mesh;
m_Object.Position.y += yAdjust;
return TRUE;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Create the font
if( FALSE == m_Font.Create( "Samples/Fonts/Tuffy12.pak" ) )
return FALSE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Samples/Textures/MotionBlur.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( "Press " FRM_FONT_KEY_0 " for Help", 1.0f, -1.0f );
m_UserInterface.AddBoolVariable( &m_bMotionBlurOn, "Motion Blur", "On", "Off" );
m_UserInterface.AddFloatVariable( &m_fSpeed, "Speed", "%4.2f" );
m_UserInterface.AddFloatVariable( &m_fShutterDuration, "Shutter Duration", "%4.4f sec" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, "Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Info Pane" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Decrease Speed" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, "Increase Speed" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, "Decrease Shutter Duration" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, "Increase Shutter Duration" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_5, "Toggle Motion Blur (on/off)" );
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
// Setup the view
FRMVECTOR3 vPosition = FRMVECTOR3( 0.0f, 0.0f, 4.0f );
FRMVECTOR3 vLookAt = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
FRMVECTOR3 vUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_matView = FrmMatrixLookAtRH( vPosition, vLookAt, vUp );
glClearColor( 0.5f, 0.5f, 0.5f, 1.0f );
return TRUE;
}
//--------------------------------------------------------------------------------------
// Name: CSample()
// Desc: Constructor
//--------------------------------------------------------------------------------------
CSample::CSample( const CHAR* strName ) : CFrmApplication( strName )
{
m_nCurShaderIndex = 0;
m_pLogoTexture = NULL;
m_nCurMeshIndex = 0;
m_pPhysicallyBasedLightingConstantBuffer = NULL;
////////////
m_SkyColor = FRMVECTOR3(0.9f, 0.1f, 0.1f);
m_GroundColor = FRMVECTOR3(0.1f, 0.1f, 0.1f);
m_MaterialSpecular = FRMVECTOR3(0.6f, 0.5f, 0.5f);
m_MaterialDiffuse = FRMVECTOR3(0.9f, 0.3f, 0.3f);
m_LightColor = FRMVECTOR3(0.9f, 0.9f, 0.9f);
m_MaterialGlossiness = 0.4f;
}
//--------------------------------------------------------------------------------------
// Name: SetCloudsShader()
// Desc:
//--------------------------------------------------------------------------------------
VOID CSample::SetCloudsShader()
{
FRMVECTOR3 cloudsColor1Vec = FRMVECTOR3( 0.0f, 0.0f, 0.5f );
FRMVECTOR3 cloudsColor2Vec = FRMVECTOR3( 1.0f, 1.0f, 1.0f );
glUseProgram( m_hCloudsShader );
glUniformMatrix4fv( m_nCloudsModelViewProjectionMatrixSlot, 1, FALSE, (FLOAT32*)&m_matModelViewProj );
glActiveTexture( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_3D_OES, m_pTurbTexture->m_hTextureHandle );
glUniform1f( m_nCloudsScaleSlot, 25.0f );
glUniform1f( m_nCloudsIntensitySlot, 1.5f + 0.5f * sinf( m_Timer.GetTime() * 2.0f ) );
glUniform3fv( m_nCloudsColor1Slot, 1, (FLOAT32*)&cloudsColor1Vec );
glUniform3fv( m_nCloudsColor2Slot, 1, (FLOAT32*)&cloudsColor2Vec );
}
//--------------------------------------------------------------------------------------
// Name: CSample()
// Desc: Constructor
//--------------------------------------------------------------------------------------
CSample::CSample( const CHAR* strName ) : CFrmApplication( strName )
{
m_hMainShader = 0;
m_hSatelliteShader = 0;
m_pSatelliteTexture = NULL;
m_pPlaqueTexture = NULL;
m_pEnvironmentMap = NULL;
m_pLogoTexture = NULL;
m_vLightPosWorld = FRMVECTOR3( -3.0, 0.5, 3.0 );
}
//--------------------------------------------------------------------------------------
// Name: Update()
// Desc:
//--------------------------------------------------------------------------------------
VOID CSample42::Update()
{
// get the current time
FLOAT32 ElapsedTime = m_Timer.GetFrameElapsedTime();
// process input
UINT32 nButtons;
UINT32 nPressedButtons;
FrmGetInput( &m_Input, &nButtons, &nPressedButtons );
// toggle user interface
if( nPressedButtons & INPUT_KEY_0 )
m_UserInterface.AdvanceState();
// toggle rotation
if( nPressedButtons & INPUT_KEY_8 )
{
m_ShouldRotate = 1 - m_ShouldRotate;
}
// update light position
m_LightPos = FRMVECTOR3( 3.3f, 2.0f, -0.42f );
// animate the camera
static FLOAT32 TotalTime = 0.0f;
if( m_ShouldRotate )
{
static FLOAT32 CameraSpeed = 1.0f;
TotalTime += ElapsedTime * CameraSpeed;
}
// build camera transforms
FRMVECTOR3 UpDir = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
FRMVECTOR3 LookPos = GetCameraPos42( TotalTime + 0.05f );
m_CameraPos = GetCameraPos42( TotalTime );
m_matView = FrmMatrixLookAtRH( m_CameraPos, LookPos, UpDir );
m_matViewProj = FrmMatrixMultiply( m_matView, m_matProj );
// update objects
m_Object.Update( ElapsedTime, m_ShouldRotate );
}
//--------------------------------------------------------------------------------------
// Name: InitEmitter()
// Desc: Initializes the particle emitter
//--------------------------------------------------------------------------------------
VOID CParticleEmitter::Init()
{
m_iParticleIndex = 0;
// Play around with the values for different effects
m_fEmissionRate = 10000.0f; // 10000 particles per second
m_vPosition = FRMVECTOR3( 0.0f, 0.0f, -0.0f );
m_vVelocity = FRMVECTOR3( -1.0f, 0.0f, 0.0f );
m_fEmitterRadius = 0.01f;
m_fEmitterSpread = 20.0f; // Emit within X degrees of the direction vector
m_fInitialLifeSpan = 5.5f; // Particle lifetime in seconds
m_fLifeSpanVariance = 1.5f;
m_fSpeedVariance = 0.5f;
m_fInitialSize = 25.0f;
m_fInitialSizeVariance = 5.0f;
m_fSizeIncreaseRate = 40.0f;
m_fSizeIncreaseRateVarience = 10.0f;
m_fInitialOpacity = 1.0f;
m_fOpacityVariance = 1.0f;
}
Shadows::Shadows() {
size = 512;
time = 0.0f;
direction = FRMVECTOR3(0.0f, 1.0f,0.0f);
technique = -1;
shadows = -1;
m_pCSMConstantBuffer = NULL;
}
//--------------------------------------------------------------------------------------
// Name:
// Desc:
//--------------------------------------------------------------------------------------
SimpleObject22::SimpleObject22()
{
Position = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
RotateTime = 0.0f;
Drawable = NULL;
BumpTexture = NULL;
DiffuseColor = FRMVECTOR4( 1.0f, 1.0f, 1.0f, 1.0f );
SpecularColor = FRMVECTOR4( 1.0f, 1.0f, 1.0f, 5.0f );
ReflectionStrength = 1.0f;
IrisGlow = 1.0f;
for( int i = 0; i < EYE_COLORS; i++ )
DiffuseTexture[i] = NULL;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample34::Initialize(CFrmFontGLES &Font, CFrmTexture* m_pLogoTexture)
{
m_ShouldRotate = TRUE;
m_Preview = false;
// Create the font
// Load the packed resources
// NOTE SAME TEXTURES AS 27
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Demos/AdrenoShaders/Textures/27_Textures.pak" ) )
return FALSE;
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( (char *)"Press \200 for Help", 1.0f, -1.0f );
m_UserInterface.AddBoolVariable( &m_ShouldRotate, (char *)"Should Rotate" );
m_UserInterface.AddFloatVariable( &m_CombineShader.GaussSpread, (char *)"Gauss filter spread" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, (char *)"Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_6, (char *)"Decrease gauss spread" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_7, (char *)"Increase gauss spread" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_8, (char *)"Toggle Rotation" );
// Load the mesh
if( FALSE == m_Mesh.Load( "Demos/AdrenoShaders/Meshes/Map3.mesh" ) )
return FALSE;
m_CameraPos = FRMVECTOR3( 6.2f, 2.0f, 0.0f );
float Split = 1.1f;
float yAdjust = -0.05f;
if( FALSE == m_Mesh.MakeDrawable( &resource ) )
return FALSE;
// Initialize the shaders
if( FALSE == InitShaders() )
{
return FALSE;
}
m_AmbientLight = FRMVECTOR4( 0.1f, 0.1f, 0.1f, 0.0f );
// Set up the objects
m_Object.Drawable = &m_Mesh;
m_Object.Position.y += yAdjust;
return TRUE;
}
//--------------------------------------------------------------------------------------
// Name: Update()
// Desc:
//--------------------------------------------------------------------------------------
VOID CSample::Update()
{
// Get the current time
FLOAT32 fElapsedTime = m_Timer.GetFrameElapsedTime();
if( m_bShouldRotate )
{
m_fRotateTime += fElapsedTime;
}
// Process input
UINT32 nButtons;
UINT32 nPressedButtons;
FrmGetInput( &m_Input, &nButtons, &nPressedButtons );
// Toggle user interface
if( nPressedButtons & INPUT_KEY_0 )
m_UserInterface.AdvanceState();
// Lower frequency
if( nButtons & INPUT_KEY_1 )
{
switch( m_nPTIndex )
{
case PT_CHECKER:
m_fCheckerFrequency -= 4.0f * fElapsedTime;
break;
case PT_WOOD:
m_fWoodFrequency -= 4.0f * fElapsedTime;
break;
case PT_MARBLE:
m_MarbleTurbScale -= 4.0f * fElapsedTime;
break;
}
}
// Increase frequency
if( nButtons & INPUT_KEY_2 )
{
switch( m_nPTIndex )
{
case PT_CHECKER:
m_fCheckerFrequency += 4.0f * fElapsedTime;
break;
case PT_WOOD:
m_fWoodFrequency += 4.0f * fElapsedTime;
break;
case PT_MARBLE:
m_MarbleTurbScale += 4.0f * fElapsedTime;
break;
}
}
// Increment shader index
if( nPressedButtons & INPUT_KEY_3 )
m_nPTIndex = ( m_nPTIndex + 1 ) % NUM_PTS;
// Toggle rotation
if( nPressedButtons & INPUT_KEY_4 )
m_bShouldRotate = 1 - m_bShouldRotate;
// Rotate the object
FRMVECTOR3 vPosition = FRMVECTOR3( 0.0f, 0.30f, 0.5f );
FRMVECTOR3 vLookAt = FRMVECTOR3( 0.0f, 0.10f, 0.0f );
FRMVECTOR3 vUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_matView = FrmMatrixLookAtRH( vPosition, vLookAt, vUp );
m_matViewProj = FrmMatrixMultiply( m_matView, m_matProj );
FRMMATRIX4X4 matModel = FrmMatrixRotate( m_fRotateTime, vUp );
// Build the matrices
m_matModelView = FrmMatrixMultiply( matModel, m_matView );
m_matModelViewProj = FrmMatrixMultiply( m_matModelView, m_matProj );
m_matNormal = FrmMatrixNormal( m_matModelViewProj );
}
//-----------------------------------------------------------------------------
// create
//-----------------------------------------------------------------------------
void SkyDome::create( const double a_radius
, const double a_height
, const int a_rings
, const int a_segments
, const double lowered
)
{
// Destroy current instance
m_vertices.clear();
m_indices .clear();
// Clamp arguments
const double dEpsilon = 1.0e-5;
const double dPI = 3.14159265358979323846;
const double dDegToRad = dPI / 180.0;
double radius = max( a_radius, dEpsilon );
double height = max( a_height, dEpsilon );
int rings = max( a_rings, 1 ) + 1;
int segments = max( a_segments, 4 ) + 1;
// Init vertex data container
m_vertices.reserve( rings * (segments + 1) );
// Fill vertex data container
for( int y = 0; y <= segments; ++y )
{
double theta = static_cast< double >( y ) / segments * 360.0 * dDegToRad;
for( int x = rings - 1; x >= 0; --x )
{
double phi = static_cast< double >( x ) / rings * 90.0 * dDegToRad;
m_vertices.push_back( FRMVECTOR3 ( static_cast< float >( sin( phi ) * cos( theta ) * radius )
, static_cast< float >( (cos( phi ) * height ) - lowered)
, static_cast< float >( sin( phi ) * sin( theta ) * radius )));
// , static_cast< float >( sin( phi ) * sin( theta ) * radius )
// , static_cast< float >( cos( phi ) * height ) ) );
}
}
// Init index container
m_indices.reserve( segments * rings * 2 );
// Fill index container
bool leftToRight = false;
for(int y = 0; y < segments; ++y )
{
if( true == leftToRight )
{
for( int x = 0; x < rings; ++x )
{
m_indices.push_back( (y + 1) * rings + x );
m_indices.push_back( y * rings + x );
}
}
else
{
for( int x = rings - 1; x >= 0; --x )
{
m_indices.push_back( y * rings + x );
m_indices.push_back( (y + 1) * rings + x );
}
}
leftToRight = !leftToRight;
}
}
//-----------------------------------------------------------------------------
// Default constructor
//-----------------------------------------------------------------------------
SkyDome::SkyDome()
{
m_sunDirection = FRMVECTOR3( 0.80f, 0.80f, 0.80f );
}
//--------------------------------------------------------------------------------------
// Name: Update()
// Desc:
//--------------------------------------------------------------------------------------
VOID CSample::Update()
{
// Get the current time
FLOAT32 fTime = m_Timer.GetFrameTime();
FLOAT32 fElapsedTime = m_Timer.GetFrameElapsedTime();
// Process input
UINT32 nButtons;
UINT32 nPressedButtons;
FrmGetInput( &m_Input, &nButtons, &nPressedButtons );
// Toggle user interface
if( nPressedButtons & INPUT_KEY_0 )
{
m_UserInterface.AdvanceState();
}
// Move shadow left
if( nButtons & INPUT_DPAD_LEFT )
{
FLOAT32 fAngle = -fElapsedTime;
FRMMATRIX4X4 matRotate = FrmMatrixRotate( fAngle, 0.0f, 0.0f, 1.0f );
FRMVECTOR4 vTmp = FrmVector3Transform( m_vLightPosition, matRotate );
m_vLightPosition = FRMVECTOR3( vTmp.x, vTmp.y, vTmp.z );
}
// Move shadow right
if( nButtons & INPUT_DPAD_RIGHT )
{
FLOAT32 fAngle = fElapsedTime;
FRMMATRIX4X4 matRotate = FrmMatrixRotate( fAngle, 0.0f, 0.0f, 1.0f );
FRMVECTOR4 vTmp = FrmVector3Transform( m_vLightPosition, matRotate );
m_vLightPosition = FRMVECTOR3( vTmp.x, vTmp.y, vTmp.z );
}
// Move shadow up
if( nButtons & INPUT_DPAD_DOWN )
{
FLOAT32 fAngle = -fElapsedTime;
FRMMATRIX4X4 matRotate = FrmMatrixRotate( fAngle, 1.0f, 0.0f, 0.0f );
FRMVECTOR4 vTmp = FrmVector3Transform( m_vLightPosition, matRotate );
m_vLightPosition = FRMVECTOR3( vTmp.x, vTmp.y, vTmp.z );
}
// Move shadow down
if( nButtons & INPUT_DPAD_UP )
{
FLOAT32 fAngle = fElapsedTime;
FRMMATRIX4X4 matRotate = FrmMatrixRotate( fAngle, 1.0f, 0.0f, 0.0f );
FRMVECTOR4 vTmp = FrmVector3Transform( m_vLightPosition, matRotate );
m_vLightPosition = FRMVECTOR3( vTmp.x, vTmp.y, vTmp.z );
}
// Change to next mesh
if( nPressedButtons & INPUT_KEY_1 )
{
m_nCurMeshIndex = ( m_nCurMeshIndex + 1 ) % NUM_MESHES;
}
// Change to next floor mesh
if( nPressedButtons & INPUT_KEY_2 )
{
m_nCurFloorIndex = ( m_nCurFloorIndex + 1 ) % NUM_FLOORS;
}
// Lower shadow map size
if( nPressedButtons & INPUT_KEY_3 )
{
if( m_nShadowMapFBOTextureExp > 5 )
{
m_nShadowMapFBOTextureExp--;
m_nShadowMapFBOTextureWidth = 2 << m_nShadowMapFBOTextureExp;
m_nShadowMapFBOTextureHeight = 2 << m_nShadowMapFBOTextureExp;
CreateShadowMapFBO();
}
}
// Increase shadow map size
if( nPressedButtons & INPUT_KEY_4 )
{
if( m_nShadowMapFBOTextureExp < 8 )
{
m_nShadowMapFBOTextureExp++;
m_nShadowMapFBOTextureWidth = 2 << m_nShadowMapFBOTextureExp;
m_nShadowMapFBOTextureHeight = 2 << m_nShadowMapFBOTextureExp;
CreateShadowMapFBO();
}
}
// Toggle PCF
if( nPressedButtons & INPUT_KEY_5 )
{
m_bUsePCF = !m_bUsePCF;
}
// Toggle display of shadow map
if( nPressedButtons & INPUT_KEY_6 )
{
m_bShowShadowMap = !m_bShowShadowMap;
}
// Setup the mesh's camera relative model view, model view projection, and normal matrices
FRMVECTOR3 yAxis = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
FRMVECTOR3 xAxis = FRMVECTOR3( 1.0f, 0.0f, 0.0f );
FRMMATRIX4X4 matMeshRotate = FrmMatrixRotate( fTime, yAxis );
FRMMATRIX4X4 matMeshRotate2 = FrmMatrixRotate( fTime, xAxis );
FRMMATRIX4X4 matMeshModel = FrmMatrixTranslate( 0.0f, 2.0f, 0.0f );
matMeshModel = FrmMatrixMultiply( matMeshRotate, matMeshModel );
matMeshModel = FrmMatrixMultiply( matMeshRotate2, matMeshModel );
m_matCameraMeshModelView = FrmMatrixMultiply( matMeshModel, m_matCameraView );
m_matCameraMeshModelViewProj = FrmMatrixMultiply( m_matCameraMeshModelView, m_matCameraPersp );
m_matCameraMeshNormal = FrmMatrixNormal( m_matCameraMeshModelView );
// Setup the floor and mesh's light relative model view projection matrices
FRMMATRIX4X4 matLightView = FrmMatrixLookAtRH( m_vLightPosition, m_vLightLookAt, m_vLightUp );
FRMMATRIX4X4 matLightModelViewProj = FrmMatrixMultiply( matLightView, m_matLightPersp );
m_matLightFloorModelViewProj = FrmMatrixMultiply( m_matFloorModel, matLightModelViewProj );
m_matLightMeshModelViewProj = FrmMatrixMultiply( matMeshModel, matLightModelViewProj );
// Setup our matrices that are used to convert vertices into shadow map lookup coordinates
m_matFloorShadowMatrix = FrmMatrixMultiply( m_matLightFloorModelViewProj, m_matScaleAndBias );
m_matMeshShadowMatrix = FrmMatrixMultiply( m_matLightMeshModelViewProj, m_matScaleAndBias );
// Setup our matrices that are used to convert vertices into diffuse/specular map lookup coordinates
m_matFloorScreenCoordMatrix = FrmMatrixMultiply( m_matCameraFloorModelViewProj, m_matScaleAndBias );
m_matMeshScreenCoordMatrix = FrmMatrixMultiply( m_matCameraMeshModelViewProj, m_matScaleAndBias );
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Initialize sample variables
m_nCurMeshIndex = CUBE_MESH;
m_bShowShadowMap = TRUE;
m_vLightPosition = FRMVECTOR3( 0.0f, 8.0f, 0.01f );
// Create the font
if( FALSE == m_Font.Create( "Samples/Fonts/Tuffy12.pak" ) )
return FALSE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Samples/Textures/ShadowMap30.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( "Press " FRM_FONT_KEY_0 " for Help", 1.0f, -1.0f, 1.0f );
m_UserInterface.AddIntVariable( &m_nShadowMapFBOTextureWidth , "Shadow Map Size", "%d" );
m_UserInterface.AddBoolVariable( &m_bUsePCF , "PCF On", "True", "False" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Help" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Next Model" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, "Next Floor" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, "Decrease Shadow Map Size" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, "Increase Shadow Map Size" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_5, "Toggle PCF" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_6, "Toggle Shadow Map Display" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_DPAD, "Rotate light" );
// Load the meshes
if( FALSE == m_Floor[ PLANE_FLOOR ].Load( "Samples/Meshes/Plane.mesh" ) )
return FALSE;
if( FALSE == m_Floor[ PLANE_FLOOR ].MakeDrawable() )
return FALSE;
if( FALSE == m_Floor[ TERRAIN_FLOOR ].Load( "Samples/Meshes/Terrain.mesh" ) )
return FALSE;
if( FALSE == m_Floor[ TERRAIN_FLOOR ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ CUBE_MESH ].Load( "Samples/Meshes/Cube.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ CUBE_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ SPHERE_MESH ].Load( "Samples/Meshes/Sphere.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ SPHERE_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ BUMPY_SPHERE_MESH ].Load( "Samples/Meshes/BumpySphere.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ BUMPY_SPHERE_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ TORUS_MESH ].Load( "Samples/Meshes/Torus.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ TORUS_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ ROCKET_MESH ].Load( "Samples/Meshes/Rocket.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ ROCKET_MESH ].MakeDrawable() )
return FALSE;
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
// Initialize the camera and light perspective matrices
FLOAT32 fAspect = (FLOAT32)m_nWidth / (FLOAT32)m_nHeight;
m_matCameraPersp = FrmMatrixPerspectiveFovRH( FRM_PI/4.0f, fAspect, 1.0f, 100.0f );
m_matLightPersp = FrmMatrixPerspectiveFovRH( FRM_PI/4.0f, 1.0f, 5.0f, 20.0f );
// Initialize the viewport
glViewport( 0, 0, m_nWidth, m_nHeight );
// Setup the FBOs
m_nShadowMapFBOTextureExp = 7;
m_nShadowMapFBOTextureWidth = 2 << m_nShadowMapFBOTextureExp;
m_nShadowMapFBOTextureHeight = 2 << m_nShadowMapFBOTextureExp;
CreateShadowMapFBO();
CreateLightingFBO();
// Setup the camera view matrix
FRMVECTOR3 vCameraPosition = FRMVECTOR3( 0.0f, 5.0f, 10.0f );
FRMVECTOR3 vCameraLookAt = FRMVECTOR3( 0.0f, 0.0f, -2.0f );
FRMVECTOR3 vCameraUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_matCameraView = FrmMatrixLookAtRH( vCameraPosition, vCameraLookAt, vCameraUp );
// Setup the floor's camera relative model view projection matrix
FRMMATRIX4X4 matFloorScale = FrmMatrixScale( 5.0f, 5.0f, 5.0f );
FRMMATRIX4X4 matFloorTranslate = FrmMatrixTranslate( 0.0f, -0.5f, 0.0f );
m_matFloorModel = FrmMatrixMultiply( matFloorScale, matFloorTranslate );
m_matCameraFloorModelView = FrmMatrixMultiply( m_matFloorModel, m_matCameraView );
m_matCameraFloorModelViewProj = FrmMatrixMultiply( m_matCameraFloorModelView, m_matCameraPersp );
m_matCameraFloorNormal = FrmMatrixNormal( m_matCameraFloorModelView );
// Setup the light look at and up vectors
m_vLightLookAt = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
m_vLightUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
// Create our scale and bias matrix that is used to convert the coordinates of vertices that are multiplied by a
// model view projection matrix from the range [-1, 1] to the range [0, 1], so that they can be used for texture lookups
m_matScaleAndBias.M( 0, 0 ) = 0.5f; m_matScaleAndBias.M( 0, 1 ) = 0.0f; m_matScaleAndBias.M( 0, 2 ) = 0.0f; m_matScaleAndBias.M( 0, 3 ) = 0.0f;
m_matScaleAndBias.M( 1, 0 ) = 0.0f; m_matScaleAndBias.M( 1, 1 ) = 0.5f; m_matScaleAndBias.M( 1, 2 ) = 0.0f; m_matScaleAndBias.M( 1, 3 ) = 0.0f;
m_matScaleAndBias.M( 2, 0 ) = 0.0f; m_matScaleAndBias.M( 2, 1 ) = 0.0f; m_matScaleAndBias.M( 2, 2 ) = 0.5f; m_matScaleAndBias.M( 2, 3 ) = 0.0f;
m_matScaleAndBias.M( 3, 0 ) = 0.5f; m_matScaleAndBias.M( 3, 1 ) = 0.5f; m_matScaleAndBias.M( 3, 2 ) = 0.5f; m_matScaleAndBias.M( 3, 3 ) = 1.0f;
// Setup GL state
glClearColor( 0.5f, 0.5f, 0.5f, 1.0f );
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LEQUAL );
// Initialization complete
m_Initialize = TRUE;
return TRUE;
}
//--------------------------------------------------------------------------------------
// Name: Update()
// Desc:
//--------------------------------------------------------------------------------------
VOID CSample::Update()
{
// Get the current time
FLOAT32 fElapsedTime = m_Timer.GetFrameElapsedTime();
if( m_bShouldRotate )
{
m_fRotateTime += fElapsedTime;
}
// Process input
UINT32 nButtons;
UINT32 nPressedButtons;
FrmGetInput( &m_Input, &nButtons, &nPressedButtons );
// Toggle user interface
if( nPressedButtons & INPUT_KEY_0 )
m_UserInterface.AdvanceState();
if( nButtons & INPUT_KEY_1 )
{
m_fOutlineWidth = FRM_MAX( m_fOutlineWidth - 0.1f * fElapsedTime, 0.0f );
m_fOutlineHalfStepSizeX = ( m_fOutlineWidth / (FLOAT32)m_nFBOTextureWidth ) / 2.0f;
m_fOutlineHalfStepSizeY = ( m_fOutlineWidth / (FLOAT32)m_nFBOTextureHeight ) / 2.0f;
}
if( nButtons & INPUT_KEY_2 )
{
m_fOutlineWidth = FRM_MIN( m_fOutlineWidth + 0.1f * fElapsedTime, 0.30f );
m_fOutlineHalfStepSizeX = ( m_fOutlineWidth / (FLOAT32)m_nFBOTextureWidth ) / 2.0f;
m_fOutlineHalfStepSizeY = ( m_fOutlineWidth / (FLOAT32)m_nFBOTextureHeight ) / 2.0f;
}
if( nButtons & INPUT_KEY_3 )
{
if( m_fAmbient > 0.01f )
m_fAmbient -= 0.2f * fElapsedTime;
}
if( nButtons & INPUT_KEY_4 )
{
if( m_fAmbient < 0.99f )
m_fAmbient += 0.2f * fElapsedTime;
}
if( nPressedButtons & INPUT_KEY_5 )
{
m_bShouldRotate = 1 - m_bShouldRotate;
}
if( nButtons & INPUT_DPAD_LEFT )
{
// Move the light to the left
m_vLightPosition.x -= 4.0f * fElapsedTime;
if( m_vLightPosition.x < -5.0f )
m_vLightPosition.x = -5.0f;
}
if( nButtons & INPUT_DPAD_RIGHT )
{
// Move the light to the right
m_vLightPosition.x += 4.0f * fElapsedTime;
if( m_vLightPosition.x > 5.0f )
m_vLightPosition.x = 5.0f;
}
if( nButtons & INPUT_DPAD_DOWN )
{
// Move the light to the left
m_vLightPosition.y -= 4.0f * fElapsedTime;
if( m_vLightPosition.y < -5.0f )
m_vLightPosition.y = -5.0f;
}
if( nButtons & INPUT_DPAD_UP )
{
// Move the light to the right
m_vLightPosition.y += 4.0f * fElapsedTime;
if( m_vLightPosition.y > 5.0f )
m_vLightPosition.y = 5.0f;
}
// Rotate the object
FRMVECTOR3 vPosition = FRMVECTOR3( 0.0f, 0.30f, 0.5f );
FRMVECTOR3 vLookAt = FRMVECTOR3( 0.0f, 0.10f, 0.0f );
FRMVECTOR3 vUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_matView = FrmMatrixLookAtRH( vPosition, vLookAt, vUp );
m_matViewProj = FrmMatrixMultiply( m_matView, m_matProj );
FRMMATRIX4X4 matModel = FrmMatrixRotate(m_fRotateTime, vUp);
// Build the matrices
m_matModelView = FrmMatrixMultiply(matModel, m_matView);
m_matModelViewProj = FrmMatrixMultiply(m_matModelView, m_matProj);
m_matNormalMatrix = FrmMatrixNormal(m_matModelView);
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Create the font
if( FALSE == m_Font.Create( "Samples/Fonts/Tuffy12.pak" ) )
return FALSE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Samples/Textures/CubeMapReflection.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
// Create the textures
m_pSatelliteTexture = resource.GetTexture( "TennisBall" );
m_pPlaqueTexture = resource.GetTexture( "Trophy_Plaque" );
m_pEnvironmentMap = resource.GetCubeMap( "BedroomCubeMap" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( "Press " FRM_FONT_KEY_0 " for Help", 1.0f, -1.0f );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, "Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Info Pane" );
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
// Load a mesh for the center of the screen
if( FALSE == m_MainObject.Load( "Samples/Meshes/trophy.mesh" ) )
return FALSE;
if( FALSE == m_MainObject.MakeDrawable( &resource ) )
return FALSE;
// Load a mesh to use for the satellite objects
if( FALSE == m_SatelliteObject.Load( "Samples/Meshes/tennisBall.mesh" ) )
return FALSE;
if( FALSE == m_SatelliteObject.MakeDrawable( &resource ) )
return FALSE;
// Create the reflection cube map
FrmCreateCubeMap( ENVMAP_SIZE, GL_UNSIGNED_SHORT_5_5_5_1, &m_hReflectionMap );
// Create an FBO for offscreen rendering
glGenFramebuffers( 1, &m_hFBOFramebufferID );
// Create a depth-buffer for offscreen rendering
FrmCreateRenderBuffer( ENVMAP_SIZE, ENVMAP_SIZE, GL_DEPTH_COMPONENT16,
&m_hFBODepthbufferID );
FRMVECTOR3 vPosition = FRMVECTOR3( -0.2f, 0.25f, 1.0f );
FRMVECTOR3 vLookAt = FRMVECTOR3( 0.0f, -0.1f, 0.0f );
FRMVECTOR3 vUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_matView = FrmMatrixLookAtRH( vPosition, vLookAt, vUp );
return TRUE;
}
#include <OpenGLES/FrmUserInterfaceGLES.h>
#include "Scene.h"
// Used to setup the six camera angles
struct CAMERA
{
FRMVECTOR3 vPosition;
FRMVECTOR3 vLookAt;
FRMVECTOR3 vUp;
};
CAMERA g_CubemapCameras[6] =
{
// vPosition vLookAt vUp
{ FRMVECTOR3( 0, 0, 0 ), FRMVECTOR3( 1, 0, 0 ), FRMVECTOR3( 0,-1, 0 ) }, // +x face
{ FRMVECTOR3( 0, 0, 0 ), FRMVECTOR3(-1, 0, 0 ), FRMVECTOR3( 0,-1, 0 ) }, // -x face
{ FRMVECTOR3( 0, 0, 0 ), FRMVECTOR3( 0, 1, 0 ), FRMVECTOR3( 0, 0, 1 ) }, // +y face
{ FRMVECTOR3( 0, 0, 0 ), FRMVECTOR3( 0,-1, 0 ), FRMVECTOR3( 0, 0,-1 ) }, // -y face
{ FRMVECTOR3( 0, 0, 0 ), FRMVECTOR3( 0, 0, 1 ), FRMVECTOR3( 0,-1, 0 ) }, // +z face
{ FRMVECTOR3( 0, 0, 0 ), FRMVECTOR3( 0, 0,-1 ), FRMVECTOR3( 0,-1, 0 ) } // -z face
};
// Size of the environment map
const UINT32 ENVMAP_SIZE = 128;
//--------------------------------------------------------------------------------------
// Name: FrmCreateApplicationInstance()
// Desc: Global function to create the application instance
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
// Name: GetCameraPos42()
// Desc:
//--------------------------------------------------------------------------------------
FRMVECTOR3 GetCameraPos42( FLOAT32 fTime )
{
FRMVECTOR3 BaseOffset = FRMVECTOR3( 4.5f, 2.0f, 0.0f );
FRMVECTOR3 CurPosition = FRMVECTOR3( 1.7f * FrmCos( 0.25f * fTime ), 0.5f * FrmSin( 0.15f * fTime ), -1.9f * FrmSin( 0.25f * fTime ) );
return BaseOffset + CurPosition;
}
