void RenderFrameDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->BeginScene();
AddImpulse();
WaterSimulation();
HeightmapToNormal();
device->SetRenderTarget(0, g_pMainFramebuffer);
device->SetDepthStencilSurface(g_pMainDepthbuffer);
device->Clear(0, NULL, D3DCLEAR_ZBUFFER, 0x0, 1.0f, 0);
RenderWater();
DrawObject();
SwapHeightmaps();
float x = -1.0f;
float y = -1.0f;
float w = 0.4f;
float h = 0.4f;
if ( g_iMode & 0x01 )
{
DrawImage(g_pTextures[TEX_HEIGHT2], x, y, w, h, &g_ImageInfo);
x+=w;
}
if ( g_iMode & 0x02 )
{
D3DXHANDLE shader = g_pWaterEffect->GetTechniqueByName("Heightmap");
D3DXHANDLE heightmap_var = g_pWaterEffect->GetTechniqueByName("heightmap_current");
g_pWaterEffect->SetTechnique(shader);
g_pWaterEffect->SetTexture(heightmap_var, g_pTextures[TEX_HEIGHT2]);
g_pWaterEffect->Begin(NULL, 0);
g_pWaterEffect->BeginPass(0);
GutDrawScreenQuad_DX9(x, y, w, h, &g_ImageInfo);
g_pWaterEffect->EndPass();
g_pWaterEffect->End();
x+=w;
}
if ( g_iMode & 0x04 )
{
DrawImage(g_pTextures[TEX_NORMAL], x, y, w, h, &g_ImageInfo);
x+=w;
}
device->EndScene();
device->Present( NULL, NULL, NULL, NULL );
}
void DirectxEngine::RenderSceneMap(const IScene& scene, float timer)
{
m_data->sceneTarget.SetActive(m_data->context);
RenderTerrain(scene);
RenderShadows();
RenderMeshes(scene);
RenderWater(scene, timer);
RenderEmitters(scene);
}
//*************************************************************************************
// Main Background Rendering Proc.
// ie: Big Mess
//*************************************************************************************
///////////////////////////////////////////////////////////
void ARX_SCENE_Render() {
ARX_PROFILE_FUNC();
if(uw_mode)
GRenderer->GetTextureStage(0)->setMipMapLODBias(10.f);
GRenderer->SetBlendFunc(Renderer::BlendZero, Renderer::BlendInvSrcColor);
for(size_t i = 0; i < RoomDrawList.size(); i++) {
ARX_PORTALS_Frustrum_RenderRoomTCullSoftRender(RoomDrawList[i]);
}
if(!player.m_improve) {
ARXDRAW_DrawInterShadows();
}
ARX_THROWN_OBJECT_Render();
GRenderer->GetTextureStage(0)->setWrapMode(TextureStage::WrapClamp);
GRenderer->GetTextureStage(0)->setMipMapLODBias(-0.6f);
RenderInter();
GRenderer->GetTextureStage(0)->setWrapMode(TextureStage::WrapRepeat);
GRenderer->GetTextureStage(0)->setMipMapLODBias(-0.3f);
// To render Dragged objs
if(DRAGINTER) {
SPECIAL_DRAGINTER_RENDER=1;
ARX_INTERFACE_RenderCursor();
SPECIAL_DRAGINTER_RENDER=0;
}
PopAllTriangleList();
// *Now* draw the player
if(entities.player()->animlayer[0].cur_anim) {
float invisibility = std::min(0.9f, entities.player()->invisibility);
AnimatedEntityRender(entities.player(), invisibility);
if(!EXTERNALVIEW) {
// In first person mode, always render the player over other objects
// in order to avoid clipping the player and weapon with walls.
GRenderer->SetRenderState(Renderer::DepthTest, false);
PopAllTriangleList(/*clear=*/false);
GRenderer->SetRenderState(Renderer::DepthTest, true);
}
PopAllTriangleList();
}
ARXDRAW_DrawEyeBall();
GRenderer->SetRenderState(Renderer::DepthWrite, false);
ARXDRAW_DrawPolyBoom();
PopAllTriangleListTransparency();
GRenderer->SetFogColor(Color::none);
GRenderer->SetRenderState(Renderer::AlphaBlending, true);
GRenderer->SetCulling(Renderer::CullNone);
GRenderer->SetRenderState(Renderer::DepthWrite, false);
GRenderer->SetAlphaFunc(Renderer::CmpGreater, .5f);
for(size_t i = 0; i < RoomDrawList.size(); i++) {
ARX_PORTALS_Frustrum_RenderRoom_TransparencyTSoftCull(RoomDrawList[i]);
}
GRenderer->SetDepthBias(8);
GRenderer->SetRenderState(Renderer::DepthWrite, false);
GRenderer->SetCulling(Renderer::CullCW);
GRenderer->SetAlphaFunc(Renderer::CmpNotEqual, 0.f);
RenderWater();
RenderLava();
GRenderer->SetDepthBias(0);
GRenderer->SetFogColor(ulBKGColor);
GRenderer->GetTextureStage(0)->setColorOp(TextureStage::OpModulate);
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
Halo_Render();
GRenderer->SetCulling(Renderer::CullCCW);
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
GRenderer->SetRenderState(Renderer::DepthWrite, true);
}
void VoxGame::Render()
{
if (m_pVoxWindow->GetMinimized())
{
// Don't call any render functions if minimized
return;
}
// Begin rendering
m_pRenderer->BeginScene(true, true, true);
// Shadow rendering to the shadow frame buffer
if (m_shadows)
{
RenderShadows();
}
// ---------------------------------------
// Render 3d
// ---------------------------------------
m_pRenderer->PushMatrix();
// Set the default projection mode
m_pRenderer->SetProjectionMode(PM_PERSPECTIVE, m_defaultViewport);
// Set back culling as default
m_pRenderer->SetCullMode(CM_BACK);
// Set default depth test
m_pRenderer->EnableDepthTest(DT_LESS);
// Set the lookat camera
m_pGameCamera->Look();
// Enable the lights
m_pRenderer->PushMatrix();
m_pRenderer->EnableLight(m_defaultLight, 0);
m_pRenderer->PopMatrix();
// Multisampling MSAA
if (m_multiSampling)
{
m_pRenderer->EnableMultiSampling();
}
else
{
m_pRenderer->DisableMultiSampling();
}
// Water reflections
if (m_waterRender && m_pChunkManager->IsUnderWater(m_pGameCamera->GetPosition()) == false && m_gameMode != GameMode_FrontEnd)
{
RenderWaterReflections();
}
// SSAO frame buffer rendering start
if (m_deferredRendering)
{
m_pRenderer->StartRenderingToFrameBuffer(m_SSAOFrameBuffer);
}
m_pRenderer->SetClearColour(0.0f, 0.0f, 0.0f, 1.0f);
m_pRenderer->ClearScene(true, true, true);
// Render the lights (DEBUG)
m_pRenderer->PushMatrix();
m_pRenderer->SetCullMode(CM_BACK);
m_pRenderer->SetRenderMode(RM_SOLID);
m_pRenderer->RenderLight(m_defaultLight);
m_pRenderer->PopMatrix();
// Render the skybox
RenderSkybox();
BeginShaderRender();
{
// Render the chunks
m_pChunkManager->Render(false);
}
EndShaderRender();
// NPC sub selection - For character creation screen
m_pNPCManager->RenderSubSelectionNormalNPCs();
// Render items outline and silhouette before the world/chunks
m_pItemManager->Render(true, false, false, false);
m_pItemManager->Render(false, false, true, false);
// NPCs (only non outline and hover)
m_pNPCManager->RenderOutlineNPCs();
m_pNPCManager->Render(false, false, true, false, false, false);
// Enemies outline
m_pEnemyManager->RenderOutlineEnemies();
m_pEnemyManager->Render(false, false, true, false);
BeginShaderRender();
{
// Scenery
m_pSceneryManager->Render(false, false, false, false, false);
// Projectiles
m_pProjectileManager->Render();
// Items
m_pItemManager->Render(false, false, false, false);
// NPCs
m_pNPCManager->ResetNumRenderNPCs();
m_pNPCManager->Render(false, false, false, false, true, false);
// Enemies
m_pEnemyManager->Render(false, false, false, false);
// NPCs (only outline and hover)
m_pNPCManager->Render(false, false, false, true, false, false);
m_pNPCManager->RenderSubSelectionOverlayNPCs();
}
EndShaderRender();
// Player selection block
m_pPlayer->RenderSelectionBlock();
// Render the block particles
m_pBlockParticleManager->Render(false);
// Render the instanced objects
if(m_instanceRender)
{
m_pInstanceManager->Render();
}
// Frontend
m_pFrontendManager->Render();
BeginShaderRender();
{
if (m_gameMode != GameMode_FrontEnd)
{
// Render the player
if (m_cameraMode != CameraMode_FirstPerson)
{
m_pPlayer->Render();
}
}
}
EndShaderRender();
// Render the transparency items above the water render, so that they appear properly under water
if (m_waterRender && m_gameMode != GameMode_FrontEnd)
{
if (m_cameraMode != CameraMode_FirstPerson)
{
m_pPlayer->RenderFace();
}
m_pNPCManager->RenderFaces();
m_pEnemyManager->RenderFaces();
if (m_cameraMode != CameraMode_FirstPerson)
{
m_pPlayer->RenderWeaponTrails();
}
m_pNPCManager->RenderWeaponTrails();
m_pEnemyManager->RenderWeaponTrails();
// Render water
RenderWater();
}
// Debug rendering
if(m_debugRender)
{
m_pLightingManager->DebugRender();
m_pBlockParticleManager->RenderDebug();
if (m_gameMode != GameMode_FrontEnd)
{
m_pPlayer->RenderDebug();
}
m_pNPCManager->RenderDebug();
m_pEnemyManager->RenderDebug();
m_pSceneryManager->RenderDebug();
m_pItemManager->RenderDebug();
m_pChunkManager->RenderDebug();
m_pProjectileManager->RenderDebug();
m_pBiomeManager->RenderDebug();
if (m_gameMode == GameMode_FrontEnd)
{
m_pFrontendManager->RenderDebug();
}
}
// Render player first person viewport
if (m_gameMode != GameMode_FrontEnd)
{
if (m_cameraMode == CameraMode_FirstPerson)
{
RenderFirstPersonViewport();
}
}
// SSAO frame buffer rendering stop
if (m_deferredRendering)
{
m_pRenderer->StopRenderingToFrameBuffer(m_SSAOFrameBuffer);
}
m_pRenderer->PopMatrix();
// Render the deferred lighting pass
if (m_dynamicLighting)
{
RenderDeferredLighting();
}
// Render other viewports
// Paperdoll for CharacterGUI
RenderPaperdollViewport();
// Portrait for HUD
if (m_pVoxSettings->m_renderGUI)
{
RenderPortraitViewport();
}
// ---------------------------------------
// Render transparency
// ---------------------------------------
RenderTransparency();
// Render the SSAO texture
if (m_deferredRendering)
{
RenderSSAOTexture();
if (m_multiSampling && m_fxaaShader != -1)
{
RenderFXAATexture();
}
if(m_blur || m_pChunkManager->IsUnderWater(m_pGameCamera->GetPosition()))
{
RenderFirstPassFullScreen();
RenderSecondPassFullScreen();
}
}
// ---------------------------------------
// Render 2d
// ---------------------------------------
m_pRenderer->PushMatrix();
// Crosshair
if (m_cameraMode == CameraMode_FirstPerson && m_bPaused == false)
{
if (m_pPlayer->IsDead() == false)
{
RenderCrosshair();
}
}
// Text effects
m_pTextEffectsManager->Render();
// Cinematic mode (letter box)
RenderCinematicLetterBox();
// Render the HUD
if (m_pVoxSettings->m_renderGUI)
{
RenderHUD();
}
m_pRenderer->PopMatrix();
// Disable multisampling for 2d gui and text
m_pRenderer->DisableMultiSampling();
// Render other deferred rendering pipelines
// Paperdoll SSAO for CharacterGUI
RenderDeferredRenderingPaperDoll();
// Portrait SSAO for HUD
if (m_pVoxSettings->m_renderGUI)
{
RenderDeferredRenderingPortrait();
}
// Render the chunks 2d (debug text information)
if (m_debugRender)
{
//m_pChunkManager->Render2D(m_pGameCamera, m_defaultViewport, m_defaultFont);
}
// Frontend 2D
if(m_gameMode == GameMode_FrontEnd)
{
m_pRenderer->PushMatrix();
m_pRenderer->SetProjectionMode(PM_2D, m_defaultViewport);
m_pRenderer->SetCullMode(CM_BACK);
m_pRenderer->SetLookAtCamera(vec3(0.0f, 0.0f, 250.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f));
m_pFrontendManager->Render2D();
m_pRenderer->PopMatrix();
}
// Render the GUI
RenderGUI();
// Custom cursor
if (m_pVoxSettings->m_customCursors && m_bCustomCursorOn)
{
if (m_gameMode != GameMode_FrontEnd || m_pFrontendManager->GetFrontendScreen() != FrontendScreen_Intro)
{
RenderCustomCursor();
}
}
// Render debug information and text
RenderDebugInformation();
// Update the NPC screen positions for select character screen
m_pNPCManager->UpdateScreenCoordinates2d(m_pGameCamera);
// End rendering
m_pRenderer->EndScene();
// Pass render call to the window class, allow to swap buffers
m_pVoxWindow->Render();
}
void BaseApp::RenderFrame()
{
m_fpsCounter.MarkFrameStart();
POINT mousePos;
GetCursorPos(&mousePos);
m_mouseX = mousePos.x - m_winPosX;
m_mouseY = mousePos.y - m_winPosY;
if(lockMouse)
{
m_camera.SetViewByMouse( float(m_mouseLockedX - m_mouseX) * 0.2f , float(m_mouseLockedY - m_mouseY) * 0.2f);
CenterMouse();
}
float height = g_heightMap->GetInterpolatedHeight(m_camera.m_vEye.x, m_camera.m_vEye.z);
//if( m_camera.m_vEye.y <= height + 2.0f )
{
float oldY = m_camera.m_vEye.y;
m_camera.m_vEye.y = height + 12.0f;
float newY = m_camera.m_vEye.y;
m_camera.m_vCenter.y += newY - oldY;
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, g_frameBuffer);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, g_texFP16.GetID(), 0);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, g_renderBuffer[0]);
glClearColor(0.8f, 1.0f, 0.8f, 1.0f);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
m_camera.BuildViewMatrix(&modelViewMat);
glLoadMatrixf(modelViewMat);
if(!m_freezeFrustum)
frustum.ComputeFrustum(projMat, modelViewMat);
glPushMatrix();
glTranslatef(m_camera.m_vEye.x, m_camera.m_vEye.y, m_camera.m_vEye.z);
glDepthMask(GL_FALSE);
m_shdSky->enable();
m_shdSky->sendUniform3f("color1", 2.0f, 2.0f, 2.0f);
m_shdSky->sendUniform3f("color2", 0.5f, 0.7f, 2.0f);
m_skydome.Render();
m_shdSky->disable();
//glDepthMask(GL_TRUE);
glPopMatrix();
Vec3 sunPos = m_sunPos * 500.0f;
glPopMatrix();
glPushMatrix();
glTranslatef(m_camera.m_vEye.x + sunPos.x, m_camera.m_vEye.y + sunPos.y, m_camera.m_vEye.z + sunPos.z);
m_texSun.Activate(0);
m_shdSimpleColor->enable();
m_shdSimpleColor->sendUniform3f("color", 4.0f, 4.0f, 2.0f);
glEnable(GL_BLEND );
glBlendFunc(GL_SRC_COLOR, GL_ONE);
RenderSprite(2000, &m_camera.m_vEye, modelViewMat);
glDisable(GL_BLEND );
m_shdSimpleColor->disable();
m_texSun.Deactivate();
glDepthMask(GL_TRUE);
glPopMatrix();
g_quadtree->Render(frustum, m_camera.m_vEye);
/*
glAlphaFunc(GL_GREATER,0.5f);
glEnable(GL_ALPHA_TEST);
Mat4 tmp;
tmp.Identity();
tmp.Translate(Vec3(0.0f, g_heightMap->GetInterpolatedHeight(0.0f, 0.0f), 0.0f));
model.render(tmp, &frustum);
tmp.Identity();
tmp.Translate(Vec3(50.0f, g_heightMap->GetInterpolatedHeight(50.0f, 0.0f), 0.0f));
model.render(tmp, &frustum);
tmp.Identity();
tmp.Translate(Vec3(0.0f, g_heightMap->GetInterpolatedHeight(0.0f, 100.0f), 100.0f));
model.render(tmp, &frustum);
tmp.Identity();
tmp.Translate(Vec3(-50.0f, g_heightMap->GetInterpolatedHeight(-50.0f, -200.0f), -200.0f));
model.render(tmp, &frustum);
glDisable(GL_ALPHA_TEST);
*/
RenderWaterReflection();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, g_texFP16.GetID(), 0);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, g_renderBuffer[0]);
g_texFP162.Bind(0);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,0, 0, m_width, m_height);
RenderWater();
RenderWaterSpecular();
RenderUnderwaterNormalMap();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
// No wireframe
glPushAttrib(GL_POLYGON_BIT);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
if(m_camera.m_vEye.y < 0)
{
m_shdUnderwater->enable();
m_shdUnderwater->sendUniform1i("g_texViewport", 0);
m_shdUnderwater->sendUniform1i("g_texNormalMap", 1);
LARGE_INTEGER time;
QueryPerformanceCounter(&time);
m_shdUnderwater->sendUniform1f("g_waterTranslation", float(time.QuadPart) * 0.000000008f);
g_texWaterReflect.Bind(1);
}
g_texFP16.Activate(0);
RenderScreenCoveringQuad();
g_texFP16.Deactivate();
/*
g_texWaterReflect.Activate(0);
RenderScreenCoveringQuad();
g_texWaterReflect.Deactivate();
*/
if(m_camera.m_vEye.y < 0)
{
m_shdUnderwater->disable();
}
BlurHDR();
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
g_texVBluredHDR.Activate(0);
RenderScreenCoveringQuad();
g_texVBluredHDR.Deactivate();
glDisable(GL_BLEND);
m_pGui->SetViewportDim(m_width, m_height);
m_pGui->Render(m_mouseX, m_mouseY, this->m_mouseButton);
m_pFont->Enable(m_width, m_height);
m_pFont->SetAlignment(FONT_HORIZ_ALIGN_RIGHT, FONT_VERT_ALIGN_TOP);
m_pFont->Print(m_width - 10, 10, "FPS: %d", (int)m_fpsCounter.GetFPS() );
m_pFont->Print(m_width - 10, 30, "Camera eye: %f, %f, %f", m_camera.m_vEye.x, m_camera.m_vEye.y, m_camera.m_vEye.z);
m_pFont->Print(m_width - 10, 50, "Camera center: %f, %f, %f", m_camera.m_vCenter.x, m_camera.m_vCenter.y, m_camera.m_vCenter.z);
m_pFont->Print(m_width - 10, 70, "Triangles rendered: %d", g_quadtree->GetNumTrisLastRendered());
m_pFont->Print(m_width - 10, 90, "VBOs data size: %d bytes", g_quadtree->m_vboDataSize);
//m_pFont->Print(m_width - 10, 110, "Mouse coords: (%d, %d)", m_mouseX, m_mouseY);
m_pFont->Disable();
/*
RenderTexDebug(3, 3, 2, g_texVBluredHDR.GetID(), "Blured HDR");
RenderTexDebug(2, 3, 2, g_texHDR.GetID(), "HDR");
RenderTexDebug(1, 3, 2, g_texFP16.GetID(), "Water refraction");
RenderTexDebug(0, 3, 2, g_texWaterReflect.GetID(), "Water reflection");
*/
glPopAttrib();
SwapBuffers(m_hDC);
m_fpsCounter.MarkFrameEnd();
}
