void gfx::GraphicsEngine::Render( RenderQueue* drawQueue ){
m_Camera.CalculateViewProjection();
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
TextureHandle target = drawQueue->GetTargetTexture();
m_FrameBuffer.SetTexture(target);
RenderToTexture(drawQueue);
RenderActiveTarget();
RenderGeometry(drawQueue);
RenderGizmos(drawQueue);
RenderSprites(drawQueue);
RenderLines(drawQueue);
glUseProgram(0);
}
static void RenderSceneGBuffer()
{
// Setup GBuffer pass //
// Enables ZTest, ZWrites, and disables culling //
float farClip = g_globalCam.GetFarClip();
g_pShaderInterface->BindShader( g_gbufferShader );
g_pShaderInterface->SetFloat( "g_farPlane", &farClip, 1 );
// Bind GBuffer //
// There is a known ATi/OpenGL bug in which bound color target clears take n * clear (n = number of targets)
// time, which is ridiculously long. Therefore we will just clear the depth buffer before they are bound
g_pTexInterface->BindRenderTarget(&g_normalDepthColor, 1, g_offscreenDepth);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
// Render cornell box and enclosed boxes to GBuffer //
RenderGeometry();
g_pShaderInterface->UnbindShader();
int def = DEFAULT_HANDLE;
g_pTexInterface->BindRenderTarget(&def, 1, DEFAULT_HANDLE);
}
void Shadows::RenderScene()
{
unsigned int i;
glDepthFunc(GL_LESS);
switch (eDisplayMode)
{
default:
//case E_NO_SHADOWS:
// RenderGeometry(uiProgram[E_DIFFUSE]);
// break;
//case E_SHADOW_VOLUMES:
// RenderGeometry(uiProgram[E_DIFFUSE]);
// for (i = 0; i < iNumLights; i++)
// {
// glEnable(GL_LIGHT0 + i);
// glLightfv(GL_LIGHT0 + i, GL_POSITION, light[i].fPos);
// }
// ShowShadowVolume();
// break;
case E_SHADOW_VOLUMES:
case E_SHADOWS:
for (i = 0; i < iNumLights; i++)
{
glEnable(GL_LIGHT0 + i);
glLightfv(GL_LIGHT0 + i, GL_POSITION, light[i].fPos);
}
/* First, render all geometry with color and depth write enabled */
RenderGeometry(uiProgram[E_DIFFUSE]);
/* Then, render the shadow volumes with color and depth write
disabled. Use the Z-fail approach */
for (i = 0; i < iNumLights; i++)
{
RenderShadowVolumes(i);
/* Finally, render again all the geometry setting a uniform
transparency factor affecting only non-zero stencil pixels
(areas in shadow) */
glDepthFunc(GL_EQUAL);
// Enable Stencil Test
glEnable(GL_STENCIL_TEST);
// update the color only where the stencil value is 0
glStencilFunc(GL_NOTEQUAL, 0, ~0);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//RenderGeometry(uiProgram[E_DIFFUSE]);
RenderGeometry(uiProgram[E_SHADOW]);
glDisable(GL_STENCIL_TEST);
glDisable(GL_BLEND);
glDepthFunc(GL_LESS);
}
break;
/*
E_STENCIL is a debug mode used to render visually the values in the
stencil buffer.
Start with same approach as normal stencil rendering, then render
multiple passes corresponding to different values in the stencil buffer.
*/
case E_STENCIL:
for (i = 0; i < iNumLights; i++)
{
glEnable(GL_LIGHT0 + i);
glLightfv(GL_LIGHT0 + i, GL_POSITION, light[i].fPos);
}
RenderGeometry(uiProgram[E_DIFFUSE]);
for (i = 0; i < iNumLights; i++)
{
RenderShadowVolumes(i);
// re-draw the model with the light enabled only where
// it has previously been drawn
glDisable(GL_DEPTH_TEST);
// update the color only where the stencil value is 0
glEnable(GL_STENCIL_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glEnable(GL_BLEND);
glDisable(GL_CULL_FACE);
glUseProgram(uiProgram[E_PLANE]);
for (unsigned int j = 1; j < 5; j++)
{
glStencilFunc(GL_EQUAL, j, ~0);
RenderPlane(uiProgram[E_PLANE], Colors + (j-1) * 4);
}
glStencilFunc(GL_GEQUAL, 5, ~0);
RenderPlane(uiProgram[E_PLANE], Colors + 16 * 4);
glDisable(GL_STENCIL_TEST);
glEnable(GL_CULL_FACE);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
break;
}
}
void RenderScene()
{
g_globalCam.Update();
// Clear Depth and color buffers //
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Enabled texturing and depth testing //
glEnable(GL_TEXTURE_2D); // Enable Texturing
glEnable(GL_DEPTH_TEST); // Enable Depth tests
glDepthFunc(GL_LEQUAL); // LESSEQUAL depth test
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
glFrontFace( GL_CCW );
// Do a depth only pass //
int rtColor = (g_bMSAA) ? g_msaaColor : DEFAULT_HANDLE;
int rtDepth = (g_bMSAA) ? g_msaaDepth : DEFAULT_HANDLE;
g_pTexInterface->BindRenderTarget(&rtColor, 1, rtDepth);
glColorMask(0, 0, 0, 0);
if(g_bMSAA)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
RenderGeometry( );
int def = DEFAULT_HANDLE;
glColorMask(1, 1, 1, 1);
// Render the gbuffer to non-msaa targets //
RenderSceneGBuffer();
RenderLightBuffer();
rtColor = (g_bMSAA) ? g_msaaColor : DEFAULT_HANDLE;
rtDepth = (g_bMSAA) ? g_msaaDepth : DEFAULT_HANDLE;
g_pTexInterface->BindRenderTarget(&rtColor, 1, rtDepth);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
rtColor = (g_bMSAA) ? g_normalDepthColor : g_lightBuffer;
vec2 viewDims = {(float)GetScreenWidth(), (float)GetScreenHeight()};
g_pShaderInterface->BindShader( g_compositeShader );
g_pShaderInterface->SetFloat( "g_viewDims", viewDims, 2 );
g_pShaderInterface->SetStateMatrix( "g_matWorldViewProj", MATRIX_MODELVIEW | MATRIX_PROJECTION );
g_pShaderInterface->SetTexture( "g_lightBuffer", rtColor );
g_pShaderInterface->SetTexture("g_diffuseTexture", g_groundTexture);
int textured = 1;
g_pShaderInterface->SetInt( "g_bIsTextured", &textured, 0 );
glDepthFunc(GL_LEQUAL);
RenderGeometry();
g_pShaderInterface->UnbindShader();
if(g_bMSAA)
{
g_pTexInterface->BindTexture(g_lightBuffer);
RenderTexturedFullscreenQuad();
// Rebind default backbuffer //
g_pTexInterface->ResolveMSAATarget(g_resolveTexture);
g_pTexInterface->BindRenderTarget(&def, 1, DEFAULT_HANDLE);
glDisable(GL_DEPTH_TEST);
g_pTexInterface->BindTexture(g_resolveTexture); // resolve tex
RenderTexturedFullscreenQuad();
}
g_pTexInterface->EvictTextures();
#ifdef RENDER_DEBUG
glDepthFunc(GL_ALWAYS);
renderDebug();
glDepthFunc(GL_LEQUAL);
#endif
glFlush();
}
