// Render the objects in their current state.
void Game::Render(){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Camera
if(placingWalls == false){
gluLookAt(camX+10, camY+10, camZ, toX, toY, toZ, 0.0f, 1.0f, 0.0f);
}
if(placingWalls == true){
gluLookAt(camX, camY+10, camZ, toX, toY, toZ, 0.0f, 1.0f, 0.0f);
}
//Objects Rendering
oPlatform->render();
mark->render();
if(goal){
goal->render();
}
//oSphere->render();
//oBox->render();
for(int i = 0; i < ARRAY_BOX_NUMBER; i++){
oBoxArray[i]->render();
}
for(int i = 0; i < ARRAY_WALL_NUMBER; i++){
if(oWall[i]){
oWall[i]->render();
}
}
//End
RenderHUD();
fCount++;
}
//RenderGame(TetrisGame* game) - depending on the game state, render the game
void RenderGame(TetrisGame* game)
{
if(game->state != TITLE_SCREEN)
{
//we are in main game mode, or a version of it - render from back to front
RenderBackground(game);
RenderBoard(game);
//if the block is falling render it
if(game->state == BLOCK_FALLING)
{
RenderBlock(game,game->currentBlockPos[0] * BLOCK_SIZE + GAME_BOARD_TOP_LEFT_X,
game->currentBlockPos[1] * BLOCK_SIZE + GAME_BOARD_TOP_LEFT_Y,game->currentBlock,true);
}
//render the score and level display etc
RenderHUD(game);
//if game over, render the game over sign
if(game->state == GAME_OVER && game->GameOverImageBool)
{
RenderImage(game,200,200,D3DXCOLOR(1.0f,1.0f,1.0f,1.0f),&(game->gameOverImage));
}
}
else
{
//otherwise, we are in title screen mode, so render the main title,
//the levels to choose from and the transparent cursor
int xOffset = 230 + (game->Level + 4) % 5 * 35;
int yOffset = 310 + (game->Level / 6) * 35;
RenderImage(game,0,0,D3DXCOLOR(1.0f,1.0f,1.0f,1.0f),&(game->titleScreen));
RenderImage(game,xOffset,yOffset,D3DXCOLOR(1.0f,1.0f,1.0f,game->transparency),&(game->cursorImg));
}
}
//--------------------------------------------------------------------------------------
// Render the scene using the D3D11 device
//--------------------------------------------------------------------------------------
void CALLBACK OnD3D11FrameRender( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext, double fTime,
float fElapsedTime, void* pUserContext )
{
XMMATRIX matView = XMLoadFloat4x4A( &g_matView );
XMMATRIX matProj = XMLoadFloat4x4A( &g_matProjection );
XMMATRIX matVP = matView * matProj;
RenderPreFrame( pd3dDevice, pd3dImmediateContext, matView, matProj, fElapsedTime );
// If the settings dialog is being shown, then render it instead of rendering the app's scene
if( g_SettingsDlg.IsActive() )
{
g_SettingsDlg.OnRender( fElapsedTime );
return;
}
if( g_bDrawTerrain )
{
g_pTerrainView->Render( pd3dImmediateContext );
}
else
{
RenderTestObjects( pd3dImmediateContext, matVP );
}
RenderHUD( pd3dImmediateContext, fElapsedTime );
static DWORD dwTimefirst = GetTickCount();
if ( GetTickCount() - dwTimefirst > 5000 )
{
OutputDebugString( DXUTGetFrameStats( DXUTIsVsyncEnabled() ) );
OutputDebugString( L"\n" );
dwTimefirst = GetTickCount();
}
}
void Game::RenderGame(void) {
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
float xOffset;
float yOffset;
int levelWidthPixels = _level->GetWidth() * _level->GetTileWidth();
int levelHeightPixels = _level->GetHeight() * _level->GetTileHeight();
if(levelWidthPixels < windowWidth && levelHeightPixels < windowHeight) {
xOffset = levelWidthPixels / 2 - windowWidth / 2;
yOffset = levelHeightPixels / 2 - windowHeight / 2;
glTranslatef((int)-xOffset, (int)-yOffset, 0.0f);
}
else
{
float windowCenterX = ((float)windowWidth / 2.0f) - ((float)_player->GetMaxWidth() / 2.0f);
float windowCenterY = ((float)windowHeight / 2.0f) - ((float)_player->GetMaxHeight() / 2.0f);
xOffset = _player->GetX() - windowCenterX;
yOffset = _player->GetY() - windowCenterY;
float maxXOffset = (float)(levelWidthPixels - windowWidth);
float maxYOffset = (float)(levelHeightPixels - windowHeight);
if(xOffset < 0.0f) xOffset = 0.0f;
if(yOffset < 0.0f) yOffset = 0.0f;
if(xOffset > maxXOffset) xOffset = maxXOffset;
if(yOffset > maxYOffset) yOffset = maxYOffset;
glTranslatef((int)-xOffset, (int)-yOffset, 0.0f);
}
// Render our shit..
_level->DrawBackground(xOffset, yOffset, _player->GetY());
_player->Render();
_level->DrawForeground(xOffset, yOffset, _player->GetY());
_testFont->SetColor(0.0f, 1.0f, 1.0f, 1.0f);
_testFont->RenderText(
_player->GetX() - 5,
_player->GetY() - _testFont->GetLineSkip() - 20,
"Miss D");
_testFont->RenderText(
_player->GetX() - 50,
_player->GetY() - _testFont->GetLineSkip() - 2,
"<Misteress of Magic>");
RenderHUD();
}
// Render the objects in their current state.
void Game::Render(){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Light
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glColor3f(1.0f, 1.0f, 0.0f);
glPushMatrix();
glTranslatef(lightPos[0], lightPos[1], lightPos[2]);
// gluSphere(lSphere, 20.0f, 20, 12);
glPopMatrix();
glEnable(GL_LIGHTING);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
if(GAMESTATE == MAINSTATESCREEN){
}
if(GAMESTATE == PLAYSTATESCREEN){
//Camera
if(placingWalls == false){
gluLookAt(camX+2, camY+5, camZ, toX, toY, toZ, 0.0f, 1.0f, 0.0f);
}
if(placingWalls == true){
gluLookAt(camX, camY+5, camZ, toX, toY, toZ, 0.0f, 1.0f, 0.0f);
}
if(oLevel1){
oLevel1->render();
}
if(goal){
goal->render();
}
//Objects Rendering
if(oSphere){
oSphere->render();
}
skyBox->render();
if(enemyf){
enemyf->output();
}
}
//End
RenderHUD();
fCount++;
}
bool CGame::Render(double deltaTime)
{
if (m_pLogic->m_renderFlags.state == RS_renderMainMenu)
{
m_pRender->VClearWindow();
m_pRender->RenderMainMenu();
}
else if (m_pLogic->m_renderFlags.state == RS_renderOptions)
{
m_pRender->VClearWindow();
m_pRender->VRenderOptions();
}
else if (m_pLogic->m_renderFlags.state == RS_renderMap)
{
m_pRender->RenderMap(m_pLogic->m_pMap);
if (m_pLogic->m_renderFlags.textBoxState == RTBS_renderFirstTextBox)
{
m_pRender->VRenderTextBox(m_pLogic->m_textRenderInfo.chars,m_pLogic->m_textRenderInfo.nextTextBox,true);
}
else if (m_pLogic->m_renderFlags.textBoxState == RTBS_renderTextBox)
{
m_pEventMessage->m_continueConversation = m_pRender->VRenderTextBox(m_pLogic->m_textRenderInfo.chars,m_pLogic->m_textRenderInfo.nextTextBox,false);
}
RenderHUD(deltaTime);
}
else if (m_pLogic->m_renderFlags.state == RS_renderMapEditor)
{
m_pRender->RenderMapEditor(m_pLogic->m_pMap);
}
else if (m_pLogic->m_renderFlags.state == RS_renderAllTiles)
{
m_pRender->RenderAllTiles(m_pLogic->m_pMap);
}
else if (m_pLogic->m_renderFlags.state == RS_renderGameExit)
{
}
m_pRender->VUpdateWindow();
return 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 ClusterCulling::DrawFrame(double deltaTime) {
if (m_sceneLoaded.load(std::memory_order_relaxed)) {
if (!m_sceneIsSetup) {
// Clean-up the thread
m_sceneLoaderThread.join();
DirectX::XMVECTOR AABB_minXM = DirectX::XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
DirectX::XMVECTOR AABB_maxXM = DirectX::XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
// Get the AABB of the scene so we can calculate the scale factors for the camera movement
for (auto iter = m_models.begin(); iter != m_models.end(); ++iter) {
AABB_minXM = DirectX::XMVectorMin(AABB_minXM, DirectX::XMVectorScale(iter->first->GetAABBMin_XM(), m_sceneScaleFactor));
AABB_maxXM = DirectX::XMVectorMax(AABB_maxXM, DirectX::XMVectorScale(iter->first->GetAABBMax_XM(), m_sceneScaleFactor));
}
for (auto iter = m_instancedModels.begin(); iter != m_instancedModels.end(); ++iter) {
for (auto transformIter = iter->second->begin(); transformIter != iter->second->end(); ++transformIter) {
AABB_minXM = DirectX::XMVectorMin(AABB_minXM, DirectX::XMVectorScale(DirectX::XMVector3Transform(iter->first->GetAABBMin_XM(), *transformIter), m_sceneScaleFactor));
AABB_maxXM = DirectX::XMVectorMax(AABB_maxXM, DirectX::XMVectorScale(DirectX::XMVector3Transform(iter->first->GetAABBMax_XM(), *transformIter), m_sceneScaleFactor));
}
}
DirectX::XMFLOAT3 AABB_min;
DirectX::XMFLOAT3 AABB_max;
DirectX::XMStoreFloat3(&AABB_min, AABB_minXM);
DirectX::XMStoreFloat3(&AABB_max, AABB_maxXM);
float min = std::min(std::min(AABB_min.x, AABB_min.y), AABB_min.z);
float max = std::max(std::max(AABB_max.x, AABB_max.y), AABB_max.z);
float range = max - min;
m_cameraPanFactor = range * 0.0002857f;
m_cameraScrollFactor = range * 0.0002857f;
m_sceneIsSetup = true;
}
RenderMainPass();
PostProcess();
} else {
// Set the backbuffer as the main render target
m_immediateContext->OMSetRenderTargets(1, &m_backbufferRTV, nullptr);
// Clear the render target view
m_immediateContext->ClearRenderTargetView(m_backbufferRTV, DirectX::Colors::LightGray);
m_spriteRenderer.Begin(m_immediateContext, Graphics::SpriteRenderer::Point);
DirectX::XMFLOAT4X4 transform {2.0f, 0.0f, 0.0f, 0.0f,
0.0f, 2.0f, 0.0f, 0.0f,
0.0f, 0.0f, 2.0f, 0.0f,
m_clientWidth / 2.0f - 90.0f, m_clientHeight / 2.0f - 30.0f, 0.0f, 1.0f};
m_spriteRenderer.RenderText(m_timesNewRoman12Font, L"Scene is loading....", transform, 0U, DirectX::XMFLOAT4(1.0f, 1.0f, 0.0f, 1.0f));
m_spriteRenderer.End();
Sleep(50);
}
RenderHUD();
if (m_showConsole) {
m_immediateContext->OMSetRenderTargets(1, &m_backbufferRTV, nullptr);
m_console.Render(m_immediateContext, deltaTime);
}
uint syncInterval = m_vsync ? 1 : 0;
m_swapChain->Present(syncInterval, 0);
}
