Unifies providing SkyManager and WaterManager like other managers, refs b889826a3d
.
This was SVN commit r26158.
This commit is contained in:
parent
7afe489214
commit
4fba543488
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -275,7 +275,7 @@ CVector3D CCamera::GetWorldCoordinates(int px, int py, bool aboveWater) const
|
||||
|
||||
CPlane plane;
|
||||
plane.Set(CVector3D(0.f, 1.f, 0.f), // upwards normal
|
||||
CVector3D(0.f, g_Renderer.GetWaterManager()->m_WaterHeight, 0.f)); // passes through water plane
|
||||
CVector3D(0.f, g_Renderer.GetWaterManager().m_WaterHeight, 0.f)); // passes through water plane
|
||||
|
||||
bool gotWater = plane.FindRayIntersection( origin, dir, &waterPoint );
|
||||
|
||||
@ -353,7 +353,7 @@ CVector3D CCamera::GetFocus() const
|
||||
|
||||
CPlane plane;
|
||||
plane.Set(CVector3D(0.f, 1.f, 0.f), // upwards normal
|
||||
CVector3D(0.f, g_Renderer.GetWaterManager()->m_WaterHeight, 0.f)); // passes through water plane
|
||||
CVector3D(0.f, g_Renderer.GetWaterManager().m_WaterHeight, 0.f)); // passes through water plane
|
||||
|
||||
bool gotWater = plane.FindRayIntersection( origin, dir, &waterPoint );
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -578,7 +578,7 @@ void CCameraController::FocusHeight(bool smooth)
|
||||
|
||||
const float ground = std::max(
|
||||
g_Game->GetWorld()->GetTerrain()->GetExactGroundLevel(nearPoint.X, nearPoint.Z),
|
||||
g_Renderer.GetWaterManager()->m_WaterHeight);
|
||||
g_Renderer.GetWaterManager().m_WaterHeight);
|
||||
|
||||
// filter ground levels for smooth camera movement
|
||||
const float filtered_near_ground = g_Game->GetWorld()->GetTerrain()->GetFilteredGroundLevel(nearPoint.X, nearPoint.Z, near_radius);
|
||||
@ -587,7 +587,7 @@ void CCameraController::FocusHeight(bool smooth)
|
||||
// filtered maximum visible ground level in view
|
||||
const float filtered_ground = std::max(
|
||||
std::max(filtered_near_ground, filtered_pivot_ground),
|
||||
g_Renderer.GetWaterManager()->m_WaterHeight);
|
||||
g_Renderer.GetWaterManager().m_WaterHeight);
|
||||
|
||||
// target camera height above pivot point
|
||||
const float pivot_height = -forwards.Y * (m_Zoom.GetSmoothedValue() - m_ViewNear);
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -254,7 +254,7 @@ void CGameView::EnumerateObjects(const CFrustum& frustum, SceneCollector* c)
|
||||
PROFILE3("submit terrain");
|
||||
|
||||
CTerrain* pTerrain = m->Game->GetWorld()->GetTerrain();
|
||||
float waterHeight = g_Renderer.GetWaterManager()->m_WaterHeight + 0.001f;
|
||||
float waterHeight = g_Renderer.GetWaterManager().m_WaterHeight + 0.001f;
|
||||
const ssize_t patchesPerSide = pTerrain->GetPatchesPerSide();
|
||||
|
||||
// find out which patches will be drawn
|
||||
@ -302,7 +302,7 @@ void CGameView::CheckLightEnv()
|
||||
void CGameView::UnloadResources()
|
||||
{
|
||||
g_TexMan.UnloadTerrainTextures();
|
||||
g_Renderer.GetWaterManager()->UnloadWaterTextures();
|
||||
g_Renderer.GetWaterManager().UnloadWaterTextures();
|
||||
}
|
||||
|
||||
void CGameView::Update(const float deltaRealTime)
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -181,7 +181,7 @@ CMiniMapTexture::~CMiniMapTexture()
|
||||
|
||||
void CMiniMapTexture::Update(const float UNUSED(deltaRealTime))
|
||||
{
|
||||
if (m_WaterHeight != g_Renderer.GetWaterManager()->m_WaterHeight)
|
||||
if (m_WaterHeight != g_Renderer.GetWaterManager().m_WaterHeight)
|
||||
{
|
||||
m_TerrainTextureDirty = true;
|
||||
m_FinalTextureDirty = true;
|
||||
@ -264,7 +264,7 @@ void CMiniMapTexture::RebuildTerrainTexture(const CTerrain* terrain)
|
||||
const u32 width = m_MapSize - 1;
|
||||
const u32 height = m_MapSize - 1;
|
||||
|
||||
m_WaterHeight = g_Renderer.GetWaterManager()->m_WaterHeight;
|
||||
m_WaterHeight = g_Renderer.GetWaterManager().m_WaterHeight;
|
||||
m_TerrainTextureDirty = false;
|
||||
|
||||
for (u32 j = 0; j < height; ++j)
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -308,7 +308,7 @@ void CMiniMap::DrawViewRect(CCanvas2D& canvas) const
|
||||
{
|
||||
// Compute the camera frustum intersected with a fixed-height plane.
|
||||
// Use the water height as a fixed base height, which should be the lowest we can go
|
||||
const float sampleHeight = g_Renderer.GetWaterManager()->m_WaterHeight;
|
||||
const float sampleHeight = g_Renderer.GetWaterManager().m_WaterHeight;
|
||||
|
||||
const CCamera* camera = g_Game->GetView()->GetCamera();
|
||||
const std::array<CVector3D, 4> hitPoints = {
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -262,7 +262,7 @@ void CGame::RegisterInit(const JS::HandleValue attribs, const std::string& saved
|
||||
m_World->RegisterInit(mapFile, *scriptInterface.GetContext(), settings, m_PlayerID);
|
||||
}
|
||||
if (m_GameView)
|
||||
RegMemFun(g_Renderer.GetSingletonPtr()->GetWaterManager(), &WaterManager::LoadWaterTextures, L"LoadWaterTextures", 80);
|
||||
RegMemFun(&g_Renderer.GetWaterManager(), &WaterManager::LoadWaterTextures, L"LoadWaterTextures", 80);
|
||||
|
||||
if (m_IsSavedGame)
|
||||
RegMemFun(this, &CGame::LoadInitialState, L"Loading game", 1000);
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2020 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -15,12 +15,6 @@
|
||||
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/**
|
||||
* File : World.cpp
|
||||
* Project : engine
|
||||
* Description : Contains the CWorld Class implementation.
|
||||
*
|
||||
**/
|
||||
#include "precompiled.h"
|
||||
|
||||
#include "graphics/GameView.h"
|
||||
@ -76,8 +70,8 @@ void CWorld::RegisterInit(const CStrW& mapFile, const ScriptContext& cx, JS::Han
|
||||
{
|
||||
CTriggerManager* pTriggerManager = NULL;
|
||||
m_MapReader->LoadMap(mapfilename, cx, settings, m_Terrain,
|
||||
CRenderer::IsInitialised() ? g_Renderer.GetWaterManager() : NULL,
|
||||
CRenderer::IsInitialised() ? g_Renderer.GetSkyManager() : NULL,
|
||||
CRenderer::IsInitialised() ? &g_Renderer.GetWaterManager() : NULL,
|
||||
CRenderer::IsInitialised() ? &g_Renderer.GetSkyManager() : NULL,
|
||||
&g_LightEnv, m_pGame->GetView(),
|
||||
m_pGame->GetView() ? m_pGame->GetView()->GetCinema() : NULL,
|
||||
pTriggerManager, CRenderer::IsInitialised() ? &g_Renderer.GetPostprocManager() : NULL,
|
||||
@ -99,8 +93,8 @@ void CWorld::RegisterInitRMS(const CStrW& scriptFile, const ScriptContext& cx, J
|
||||
// If scriptFile is empty, a blank map will be generated using settings (no RMS run)
|
||||
CTriggerManager* pTriggerManager = NULL;
|
||||
m_MapReader->LoadRandomMap(scriptFile, cx, settings, m_Terrain,
|
||||
CRenderer::IsInitialised() ? g_Renderer.GetWaterManager() : NULL,
|
||||
CRenderer::IsInitialised() ? g_Renderer.GetSkyManager() : NULL,
|
||||
CRenderer::IsInitialised() ? &g_Renderer.GetWaterManager() : NULL,
|
||||
CRenderer::IsInitialised() ? &g_Renderer.GetSkyManager() : NULL,
|
||||
&g_LightEnv, m_pGame->GetView(),
|
||||
m_pGame->GetView() ? m_pGame->GetView()->GetCinema() : NULL,
|
||||
pTriggerManager, CRenderer::IsInitialised() ? &g_Renderer.GetPostprocManager() : NULL,
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -726,15 +726,15 @@ void ShaderModelRenderer::Render(const RenderModifierPtr& modifier, const CShade
|
||||
else if (rq.first == RQUERY_WATER_TEX)
|
||||
{
|
||||
const double period = 1.6;
|
||||
WaterManager* waterManager = g_Renderer.GetWaterManager();
|
||||
if (waterManager->m_RenderWater && waterManager->WillRenderFancyWater())
|
||||
shader->BindTexture(str_waterTex, waterManager->m_NormalMap[waterManager->GetCurrentTextureIndex(period)]);
|
||||
const WaterManager& waterManager = g_Renderer.GetWaterManager();
|
||||
if (waterManager.m_RenderWater && waterManager.WillRenderFancyWater())
|
||||
shader->BindTexture(str_waterTex, waterManager.m_NormalMap[waterManager.GetCurrentTextureIndex(period)]);
|
||||
else
|
||||
shader->BindTexture(str_waterTex, g_Renderer.GetTextureManager().GetErrorTexture());
|
||||
}
|
||||
else if (rq.first == RQUERY_SKY_CUBE)
|
||||
{
|
||||
shader->BindTexture(str_skyCube, g_Renderer.GetSkyManager()->GetSkyCube());
|
||||
shader->BindTexture(str_skyCube, g_Renderer.GetSkyManager().GetSkyCube());
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -1232,7 +1232,7 @@ void CPatchRData::BuildWater()
|
||||
u16 water_shore_index_map[PATCH_SIZE+1][PATCH_SIZE+1];
|
||||
memset(water_shore_index_map, 0xFF, sizeof(water_shore_index_map));
|
||||
|
||||
WaterManager* WaterMgr = g_Renderer.GetWaterManager();
|
||||
const WaterManager& waterManager = g_Renderer.GetWaterManager();
|
||||
|
||||
CPatch* patch = m_Patch;
|
||||
CTerrain* terrain = patch->m_Parent;
|
||||
@ -1303,7 +1303,7 @@ void CPatchRData::BuildWater()
|
||||
|
||||
m_WaterBounds += vertex.m_Position;
|
||||
|
||||
vertex.m_WaterData = CVector2D(WaterMgr->m_WindStrength[xx + zz*mapSize], depth);
|
||||
vertex.m_WaterData = CVector2D(waterManager.m_WindStrength[xx + zz*mapSize], depth);
|
||||
|
||||
water_index_map[z+moves[i][1]][x+moves[i][0]] = static_cast<u16>(water_vertex_data.size());
|
||||
water_vertex_data.push_back(vertex);
|
||||
@ -1416,8 +1416,8 @@ void CPatchRData::RenderWater(CShaderProgramPtr& shader, bool onlyShore, bool fi
|
||||
}
|
||||
|
||||
if (m_VBWaterShore && g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB &&
|
||||
g_Renderer.GetWaterManager()->m_WaterEffects &&
|
||||
g_Renderer.GetWaterManager()->m_WaterFancyEffects)
|
||||
g_Renderer.GetWaterManager().m_WaterEffects &&
|
||||
g_Renderer.GetWaterManager().m_WaterFancyEffects)
|
||||
{
|
||||
SWaterVertex *base=(SWaterVertex *)m_VBWaterShore->m_Owner->Bind();
|
||||
|
||||
|
@ -392,8 +392,6 @@ public:
|
||||
CRenderer::CRenderer()
|
||||
{
|
||||
m = new CRendererInternals;
|
||||
m_WaterManager = &m->waterManager;
|
||||
m_SkyManager = &m->skyManager;
|
||||
|
||||
g_ProfileViewer.AddRootTable(&m->profileTable);
|
||||
|
||||
@ -583,7 +581,7 @@ void CRenderer::Resize(int width, int height)
|
||||
|
||||
m->postprocManager.Resize();
|
||||
|
||||
m_WaterManager->Resize();
|
||||
m->waterManager.Resize();
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
@ -1232,9 +1230,9 @@ void CRenderer::RenderSubmissions(const CBoundingBoxAligned& waterScissor)
|
||||
|
||||
ogl_WarnIfError();
|
||||
|
||||
if (m_WaterManager->m_RenderWater)
|
||||
if (m->waterManager.m_RenderWater)
|
||||
{
|
||||
if (waterScissor.GetVolume() > 0 && m_WaterManager->WillRenderFancyWater())
|
||||
if (waterScissor.GetVolume() > 0 && m->waterManager.WillRenderFancyWater())
|
||||
{
|
||||
PROFILE3_GPU("water scissor");
|
||||
RenderReflections(context, waterScissor);
|
||||
@ -1279,9 +1277,9 @@ void CRenderer::RenderSubmissions(const CBoundingBoxAligned& waterScissor)
|
||||
ogl_WarnIfError();
|
||||
|
||||
// render water
|
||||
if (m_WaterManager->m_RenderWater && g_Game && waterScissor.GetVolume() > 0)
|
||||
if (m->waterManager.m_RenderWater && g_Game && waterScissor.GetVolume() > 0)
|
||||
{
|
||||
if (m_WaterManager->WillRenderFancyWater())
|
||||
if (m->waterManager.WillRenderFancyWater())
|
||||
{
|
||||
// Render transparent stuff, but only the solid parts that can occlude block water.
|
||||
RenderTransparentModels(context, cullGroup, TRANSPARENT_OPAQUE, false);
|
||||
@ -1589,11 +1587,11 @@ void CRenderer::RenderScene(Scene& scene)
|
||||
}
|
||||
|
||||
CBoundingBoxAligned waterScissor;
|
||||
if (m_WaterManager->m_RenderWater)
|
||||
if (m->waterManager.m_RenderWater)
|
||||
{
|
||||
waterScissor = m->terrainRenderer.ScissorWater(CULL_DEFAULT, m_ViewCamera);
|
||||
|
||||
if (waterScissor.GetVolume() > 0 && m_WaterManager->WillRenderFancyWater())
|
||||
if (waterScissor.GetVolume() > 0 && m->waterManager.WillRenderFancyWater())
|
||||
{
|
||||
if (g_RenderingOptions.GetWaterReflection())
|
||||
{
|
||||
@ -1616,7 +1614,7 @@ void CRenderer::RenderScene(Scene& scene)
|
||||
}
|
||||
|
||||
// Render the waves to the Fancy effects texture
|
||||
m_WaterManager->RenderWaves(frustum);
|
||||
m->waterManager.RenderWaves(frustum);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1647,7 +1645,17 @@ void CRenderer::BindTexture(int unit, GLuint tex)
|
||||
void CRenderer::MakeShadersDirty()
|
||||
{
|
||||
m->ShadersDirty = true;
|
||||
m_WaterManager->m_NeedsReloading = true;
|
||||
m->waterManager.m_NeedsReloading = true;
|
||||
}
|
||||
|
||||
WaterManager& CRenderer::GetWaterManager()
|
||||
{
|
||||
return m->waterManager;
|
||||
}
|
||||
|
||||
SkyManager& CRenderer::GetSkyManager()
|
||||
{
|
||||
return m->skyManager;
|
||||
}
|
||||
|
||||
CTextureManager& CRenderer::GetTextureManager()
|
||||
|
@ -235,14 +235,14 @@ public:
|
||||
*
|
||||
* @return the WaterManager object used by the renderer
|
||||
*/
|
||||
WaterManager* GetWaterManager() { return m_WaterManager; }
|
||||
WaterManager& GetWaterManager();
|
||||
|
||||
/**
|
||||
* GetSkyManager: Return the renderer's sky manager.
|
||||
*
|
||||
* @return the SkyManager object used by the renderer
|
||||
*/
|
||||
SkyManager* GetSkyManager() { return m_SkyManager; }
|
||||
SkyManager& GetSkyManager();
|
||||
|
||||
CTextureManager& GetTextureManager();
|
||||
|
||||
@ -394,17 +394,6 @@ protected:
|
||||
// per-frame renderer stats
|
||||
Stats m_Stats;
|
||||
|
||||
/**
|
||||
* m_WaterManager: the WaterManager object used for water textures and settings
|
||||
* (e.g. water color, water height)
|
||||
*/
|
||||
WaterManager* m_WaterManager;
|
||||
|
||||
/**
|
||||
* m_SkyManager: the SkyManager object used for sky textures and settings
|
||||
*/
|
||||
SkyManager* m_SkyManager;
|
||||
|
||||
/**
|
||||
* Enable rendering of terrain tile priority text overlay, for debugging.
|
||||
*/
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -195,7 +195,7 @@ void TerrainRenderer::RenderTerrainOverlayTexture(int cullGroup, CMatrix3D& text
|
||||
if (!waterBounds.IsEmpty())
|
||||
{
|
||||
// Add a delta to avoid z-fighting.
|
||||
const float height = g_Renderer.GetWaterManager()->m_WaterHeight + 0.05f;
|
||||
const float height = g_Renderer.GetWaterManager().m_WaterHeight + 0.05f;
|
||||
const float waterPos[] = {
|
||||
waterBounds[0].X, height, waterBounds[0].Z,
|
||||
waterBounds[1].X, height, waterBounds[0].Z,
|
||||
@ -356,19 +356,19 @@ bool TerrainRenderer::RenderFancyWater(const CShaderDefines& context, int cullGr
|
||||
PROFILE3_GPU("fancy water");
|
||||
OGL_SCOPED_DEBUG_GROUP("Render Fancy Water");
|
||||
|
||||
WaterManager* waterManager = g_Renderer.GetWaterManager();
|
||||
WaterManager& waterManager = g_Renderer.GetWaterManager();
|
||||
CShaderDefines defines = context;
|
||||
|
||||
// If we're using fancy water, make sure its shader is loaded
|
||||
if (!m->fancyWaterTech || waterManager->m_NeedsReloading)
|
||||
if (!m->fancyWaterTech || waterManager.m_NeedsReloading)
|
||||
{
|
||||
if (waterManager->m_WaterRealDepth)
|
||||
if (waterManager.m_WaterRealDepth)
|
||||
defines.Add(str_USE_REAL_DEPTH, str_1);
|
||||
if (waterManager->m_WaterFancyEffects)
|
||||
if (waterManager.m_WaterFancyEffects)
|
||||
defines.Add(str_USE_FANCY_EFFECTS, str_1);
|
||||
if (waterManager->m_WaterRefraction)
|
||||
if (waterManager.m_WaterRefraction)
|
||||
defines.Add(str_USE_REFRACTION, str_1);
|
||||
if (waterManager->m_WaterReflection)
|
||||
if (waterManager.m_WaterReflection)
|
||||
defines.Add(str_USE_REFLECTION, str_1);
|
||||
|
||||
m->fancyWaterTech = g_Renderer.GetShaderManager().LoadEffect(str_water_high, defines);
|
||||
@ -376,10 +376,10 @@ bool TerrainRenderer::RenderFancyWater(const CShaderDefines& context, int cullGr
|
||||
if (!m->fancyWaterTech)
|
||||
{
|
||||
LOGERROR("Failed to load water shader. Falling back to a simple water.\n");
|
||||
waterManager->m_RenderWater = false;
|
||||
waterManager.m_RenderWater = false;
|
||||
return false;
|
||||
}
|
||||
waterManager->m_NeedsReloading = false;
|
||||
waterManager.m_NeedsReloading = false;
|
||||
}
|
||||
|
||||
CLOSTexture& losTexture = g_Renderer.GetScene().GetLOSTexture();
|
||||
@ -391,17 +391,17 @@ bool TerrainRenderer::RenderFancyWater(const CShaderDefines& context, int cullGr
|
||||
WaterMgr->CreateSuperfancyInfo();
|
||||
}*/
|
||||
|
||||
const double time = waterManager->m_WaterTexTimer;
|
||||
const float repeatPeriod = waterManager->m_RepeatPeriod;
|
||||
const double time = waterManager.m_WaterTexTimer;
|
||||
const float repeatPeriod = waterManager.m_RepeatPeriod;
|
||||
|
||||
// Render normals and foam to a framebuffer if we're in fancy effects
|
||||
if (waterManager->m_WaterFancyEffects)
|
||||
if (waterManager.m_WaterFancyEffects)
|
||||
{
|
||||
// Save the post-processing framebuffer.
|
||||
GLint fbo;
|
||||
glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fbo);
|
||||
|
||||
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, waterManager->m_FancyEffectsFBO);
|
||||
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, waterManager.m_FancyEffectsFBO);
|
||||
|
||||
glDisable(GL_BLEND);
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
@ -437,51 +437,51 @@ bool TerrainRenderer::RenderFancyWater(const CShaderDefines& context, int cullGr
|
||||
const CCamera& camera = g_Renderer.GetViewCamera();
|
||||
|
||||
const double period = 8.0;
|
||||
fancyWaterShader->BindTexture(str_normalMap, waterManager->m_NormalMap[waterManager->GetCurrentTextureIndex(period)]);
|
||||
fancyWaterShader->BindTexture(str_normalMap2, waterManager->m_NormalMap[waterManager->GetNextTextureIndex(period)]);
|
||||
fancyWaterShader->BindTexture(str_normalMap, waterManager.m_NormalMap[waterManager.GetCurrentTextureIndex(period)]);
|
||||
fancyWaterShader->BindTexture(str_normalMap2, waterManager.m_NormalMap[waterManager.GetNextTextureIndex(period)]);
|
||||
|
||||
if (waterManager->m_WaterFancyEffects)
|
||||
if (waterManager.m_WaterFancyEffects)
|
||||
{
|
||||
fancyWaterShader->BindTexture(str_waterEffectsTex, waterManager->m_FancyTexture.get());
|
||||
fancyWaterShader->BindTexture(str_waterEffectsTex, waterManager.m_FancyTexture.get());
|
||||
}
|
||||
|
||||
if (waterManager->m_WaterRefraction && waterManager->m_WaterRealDepth)
|
||||
if (waterManager.m_WaterRefraction && waterManager.m_WaterRealDepth)
|
||||
{
|
||||
fancyWaterShader->BindTexture(str_depthTex, waterManager->m_RefrFboDepthTexture.get());
|
||||
fancyWaterShader->Uniform(str_projInvTransform, waterManager->m_RefractionProjInvMatrix);
|
||||
fancyWaterShader->Uniform(str_viewInvTransform, waterManager->m_RefractionViewInvMatrix);
|
||||
fancyWaterShader->BindTexture(str_depthTex, waterManager.m_RefrFboDepthTexture.get());
|
||||
fancyWaterShader->Uniform(str_projInvTransform, waterManager.m_RefractionProjInvMatrix);
|
||||
fancyWaterShader->Uniform(str_viewInvTransform, waterManager.m_RefractionViewInvMatrix);
|
||||
}
|
||||
|
||||
if (waterManager->m_WaterRefraction)
|
||||
fancyWaterShader->BindTexture(str_refractionMap, waterManager->m_RefractionTexture.get());
|
||||
if (waterManager->m_WaterReflection)
|
||||
fancyWaterShader->BindTexture(str_reflectionMap, waterManager->m_ReflectionTexture.get());
|
||||
if (waterManager.m_WaterRefraction)
|
||||
fancyWaterShader->BindTexture(str_refractionMap, waterManager.m_RefractionTexture.get());
|
||||
if (waterManager.m_WaterReflection)
|
||||
fancyWaterShader->BindTexture(str_reflectionMap, waterManager.m_ReflectionTexture.get());
|
||||
fancyWaterShader->BindTexture(str_losTex, losTexture.GetTextureSmooth());
|
||||
|
||||
const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
|
||||
|
||||
fancyWaterShader->Uniform(str_transform, g_Renderer.GetViewCamera().GetViewProjection());
|
||||
|
||||
fancyWaterShader->BindTexture(str_skyCube, g_Renderer.GetSkyManager()->GetSkyCube());
|
||||
fancyWaterShader->BindTexture(str_skyCube, g_Renderer.GetSkyManager().GetSkyCube());
|
||||
// TODO: check that this rotates in the right direction.
|
||||
CMatrix3D skyBoxRotation;
|
||||
skyBoxRotation.SetIdentity();
|
||||
skyBoxRotation.RotateY(M_PI + lightEnv.GetRotation());
|
||||
fancyWaterShader->Uniform(str_skyBoxRot, skyBoxRotation);
|
||||
|
||||
if (waterManager->m_WaterRefraction)
|
||||
fancyWaterShader->Uniform(str_refractionMatrix, waterManager->m_RefractionMatrix);
|
||||
if (waterManager->m_WaterReflection)
|
||||
fancyWaterShader->Uniform(str_reflectionMatrix, waterManager->m_ReflectionMatrix);
|
||||
if (waterManager.m_WaterRefraction)
|
||||
fancyWaterShader->Uniform(str_refractionMatrix, waterManager.m_RefractionMatrix);
|
||||
if (waterManager.m_WaterReflection)
|
||||
fancyWaterShader->Uniform(str_reflectionMatrix, waterManager.m_ReflectionMatrix);
|
||||
|
||||
fancyWaterShader->Uniform(str_ambient, lightEnv.m_AmbientColor);
|
||||
fancyWaterShader->Uniform(str_sunDir, lightEnv.GetSunDir());
|
||||
fancyWaterShader->Uniform(str_sunColor, lightEnv.m_SunColor);
|
||||
fancyWaterShader->Uniform(str_color, waterManager->m_WaterColor);
|
||||
fancyWaterShader->Uniform(str_tint, waterManager->m_WaterTint);
|
||||
fancyWaterShader->Uniform(str_waviness, waterManager->m_Waviness);
|
||||
fancyWaterShader->Uniform(str_murkiness, waterManager->m_Murkiness);
|
||||
fancyWaterShader->Uniform(str_windAngle, waterManager->m_WindAngle);
|
||||
fancyWaterShader->Uniform(str_color, waterManager.m_WaterColor);
|
||||
fancyWaterShader->Uniform(str_tint, waterManager.m_WaterTint);
|
||||
fancyWaterShader->Uniform(str_waviness, waterManager.m_Waviness);
|
||||
fancyWaterShader->Uniform(str_murkiness, waterManager.m_Murkiness);
|
||||
fancyWaterShader->Uniform(str_windAngle, waterManager.m_WindAngle);
|
||||
fancyWaterShader->Uniform(str_repeatScale, 1.0f / repeatPeriod);
|
||||
fancyWaterShader->Uniform(str_losTransform, losTexture.GetTextureMatrix()[0], losTexture.GetTextureMatrix()[12], 0.f, 0.f);
|
||||
|
||||
@ -492,12 +492,12 @@ bool TerrainRenderer::RenderFancyWater(const CShaderDefines& context, int cullGr
|
||||
fancyWaterShader->Uniform(str_time, (float)time);
|
||||
fancyWaterShader->Uniform(str_screenSize, (float)g_Renderer.GetWidth(), (float)g_Renderer.GetHeight(), 0.0f, 0.0f);
|
||||
|
||||
if (waterManager->m_WaterType == L"clap")
|
||||
if (waterManager.m_WaterType == L"clap")
|
||||
{
|
||||
fancyWaterShader->Uniform(str_waveParams1, 30.0f,1.5f,20.0f,0.03f);
|
||||
fancyWaterShader->Uniform(str_waveParams2, 0.5f,0.0f,0.0f,0.0f);
|
||||
}
|
||||
else if (waterManager->m_WaterType == L"lake")
|
||||
else if (waterManager.m_WaterType == L"lake")
|
||||
{
|
||||
fancyWaterShader->Uniform(str_waveParams1, 8.5f,1.5f,15.0f,0.03f);
|
||||
fancyWaterShader->Uniform(str_waveParams2, 0.2f,0.0f,0.0f,0.07f);
|
||||
@ -533,15 +533,13 @@ void TerrainRenderer::RenderSimpleWater(int cullGroup)
|
||||
PROFILE3_GPU("simple water");
|
||||
OGL_SCOPED_DEBUG_GROUP("Render Simple Water");
|
||||
|
||||
WaterManager* WaterMgr = g_Renderer.GetWaterManager();
|
||||
const WaterManager& waterManager = g_Renderer.GetWaterManager();
|
||||
CLOSTexture& losTexture = g_Game->GetView()->GetLOSTexture();
|
||||
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glDepthFunc(GL_LEQUAL);
|
||||
|
||||
double time = WaterMgr->m_WaterTexTimer;
|
||||
double period = 1.6f;
|
||||
int curTex = (int)(time*60/period) % 60;
|
||||
const double time = waterManager.m_WaterTexTimer;
|
||||
|
||||
CShaderTechniquePtr waterSimpleTech =
|
||||
g_Renderer.GetShaderManager().LoadEffect(str_water_simple);
|
||||
@ -549,12 +547,12 @@ void TerrainRenderer::RenderSimpleWater(int cullGroup)
|
||||
CShaderProgramPtr waterSimpleShader = waterSimpleTech->GetShader();
|
||||
|
||||
waterSimpleShader->Bind();
|
||||
waterSimpleShader->BindTexture(str_baseTex, WaterMgr->m_WaterTexture[curTex]);
|
||||
waterSimpleShader->BindTexture(str_baseTex, waterManager.m_WaterTexture[waterManager.GetCurrentTextureIndex(1.6)]);
|
||||
waterSimpleShader->BindTexture(str_losTex, losTexture.GetTextureSmooth());
|
||||
waterSimpleShader->Uniform(str_transform, g_Renderer.GetViewCamera().GetViewProjection());
|
||||
waterSimpleShader->Uniform(str_losTransform, losTexture.GetTextureMatrix()[0], losTexture.GetTextureMatrix()[12], 0.f, 0.f);
|
||||
waterSimpleShader->Uniform(str_time, static_cast<float>(time));
|
||||
waterSimpleShader->Uniform(str_color, WaterMgr->m_WaterColor);
|
||||
waterSimpleShader->Uniform(str_color, waterManager.m_WaterColor);
|
||||
|
||||
std::vector<CPatchRData*>& visiblePatches = m->visiblePatches[cullGroup];
|
||||
for (size_t i = 0; i < visiblePatches.size(); ++i)
|
||||
@ -576,11 +574,11 @@ void TerrainRenderer::RenderSimpleWater(int cullGroup)
|
||||
// Render water that is part of the terrain
|
||||
void TerrainRenderer::RenderWater(const CShaderDefines& context, int cullGroup, ShadowMap* shadow)
|
||||
{
|
||||
WaterManager* WaterMgr = g_Renderer.GetWaterManager();
|
||||
WaterManager& waterManager = g_Renderer.GetWaterManager();
|
||||
|
||||
WaterMgr->UpdateQuality();
|
||||
waterManager.UpdateQuality();
|
||||
|
||||
if (!WaterMgr->WillRenderFancyWater())
|
||||
if (!waterManager.WillRenderFancyWater())
|
||||
RenderSimpleWater(cullGroup);
|
||||
else
|
||||
RenderFancyWater(context, cullGroup, shadow);
|
||||
|
@ -144,8 +144,8 @@ public:
|
||||
|
||||
if (ReloadWater && CRenderer::IsInitialised())
|
||||
{
|
||||
g_Renderer.GetWaterManager()->SetMapSize(vertices);
|
||||
g_Renderer.GetWaterManager()->RecomputeWaterData();
|
||||
g_Renderer.GetWaterManager().SetMapSize(vertices);
|
||||
g_Renderer.GetWaterManager().RecomputeWaterData();
|
||||
}
|
||||
MakeDirty(0, 0, tiles+1, tiles+1);
|
||||
}
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -57,7 +57,7 @@ public:
|
||||
{
|
||||
// Clear the map size & data.
|
||||
if (CRenderer::IsInitialised())
|
||||
g_Renderer.GetWaterManager()->SetMapSize(0);
|
||||
g_Renderer.GetWaterManager().SetMapSize(0);
|
||||
}
|
||||
|
||||
virtual void Serialize(ISerializer& serialize)
|
||||
@ -72,7 +72,7 @@ public:
|
||||
deserialize.NumberFixed_Unbounded("height", m_WaterHeight);
|
||||
|
||||
if (CRenderer::IsInitialised())
|
||||
g_Renderer.GetWaterManager()->SetMapSize(GetSimContext().GetTerrain().GetVerticesPerSide());
|
||||
g_Renderer.GetWaterManager().SetMapSize(GetSimContext().GetTerrain().GetVerticesPerSide());
|
||||
|
||||
RecomputeWaterData();
|
||||
}
|
||||
@ -85,7 +85,7 @@ public:
|
||||
{
|
||||
const CMessageInterpolate& msgData = static_cast<const CMessageInterpolate&> (msg);
|
||||
if (CRenderer::IsInitialised())
|
||||
g_Renderer.GetWaterManager()->m_WaterTexTimer += msgData.deltaSimTime;
|
||||
g_Renderer.GetWaterManager().m_WaterTexTimer += msgData.deltaSimTime;
|
||||
break;
|
||||
}
|
||||
case MT_TerrainChanged:
|
||||
@ -105,8 +105,8 @@ public:
|
||||
{
|
||||
if (CRenderer::IsInitialised())
|
||||
{
|
||||
g_Renderer.GetWaterManager()->RecomputeWaterData();
|
||||
g_Renderer.GetWaterManager()->m_WaterHeight = m_WaterHeight.ToFloat();
|
||||
g_Renderer.GetWaterManager().RecomputeWaterData();
|
||||
g_Renderer.GetWaterManager().m_WaterHeight = m_WaterHeight.ToFloat();
|
||||
}
|
||||
|
||||
// Tell the terrain it'll need to recompute its cached render data
|
||||
|
@ -445,18 +445,18 @@ void ActorViewer::SetEnabled(bool enabled)
|
||||
m.OldShadows = g_RenderingOptions.GetShadows();
|
||||
SetShadowsEnabled(m.ShadowsEnabled);
|
||||
|
||||
m.OldSky = g_Renderer.GetSkyManager()->GetRenderSky();
|
||||
g_Renderer.GetSkyManager()->SetRenderSky(false);
|
||||
m.OldSky = g_Renderer.GetSkyManager().GetRenderSky();
|
||||
g_Renderer.GetSkyManager().SetRenderSky(false);
|
||||
|
||||
m.OldWater = g_Renderer.GetWaterManager()->m_RenderWater;
|
||||
g_Renderer.GetWaterManager()->m_RenderWater = m.WaterEnabled;
|
||||
m.OldWater = g_Renderer.GetWaterManager().m_RenderWater;
|
||||
g_Renderer.GetWaterManager().m_RenderWater = m.WaterEnabled;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Restore the old renderer state
|
||||
SetShadowsEnabled(m.OldShadows);
|
||||
g_Renderer.GetSkyManager()->SetRenderSky(m.OldSky);
|
||||
g_Renderer.GetWaterManager()->m_RenderWater = m.OldWater;
|
||||
g_Renderer.GetSkyManager().SetRenderSky(m.OldSky);
|
||||
g_Renderer.GetWaterManager().m_RenderWater = m.OldWater;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -45,16 +45,16 @@ sEnvironmentSettings GetSettings()
|
||||
|
||||
s.waterheight = cmpWaterManager->GetExactWaterLevel(0, 0) / (65536.f * HEIGHT_SCALE);
|
||||
|
||||
WaterManager* wm = g_Renderer.GetWaterManager();
|
||||
s.watertype = wm->m_WaterType;
|
||||
s.waterwaviness = wm->m_Waviness;
|
||||
s.watermurkiness = wm->m_Murkiness;
|
||||
s.windangle = wm->m_WindAngle;
|
||||
const WaterManager& waterManager = g_Renderer.GetWaterManager();
|
||||
s.watertype = waterManager.m_WaterType;
|
||||
s.waterwaviness = waterManager.m_Waviness;
|
||||
s.watermurkiness = waterManager.m_Murkiness;
|
||||
s.windangle = waterManager.m_WindAngle;
|
||||
|
||||
// CColor colors
|
||||
#define COLOR(A, B) A = Color((int)(B.r*255), (int)(B.g*255), (int)(B.b*255))
|
||||
COLOR(s.watercolor, wm->m_WaterColor);
|
||||
COLOR(s.watertint, wm->m_WaterTint);
|
||||
COLOR(s.watercolor, waterManager.m_WaterColor);
|
||||
COLOR(s.watertint, waterManager.m_WaterTint);
|
||||
#undef COLOR
|
||||
|
||||
float sunrotation = g_LightEnv.GetRotation();
|
||||
@ -65,7 +65,7 @@ sEnvironmentSettings GetSettings()
|
||||
|
||||
s.posteffect = g_Renderer.GetPostprocManager().GetPostEffect();
|
||||
|
||||
s.skyset = g_Renderer.GetSkyManager()->GetSkySet();
|
||||
s.skyset = g_Renderer.GetSkyManager().GetSkySet();
|
||||
|
||||
s.fogfactor = g_LightEnv.m_FogFactor;
|
||||
s.fogmax = g_LightEnv.m_FogMax;
|
||||
@ -99,19 +99,19 @@ void SetSettings(const sEnvironmentSettings& s)
|
||||
|
||||
cmpWaterManager->SetWaterLevel(entity_pos_t::FromFloat(s.waterheight * (65536.f * HEIGHT_SCALE)));
|
||||
|
||||
WaterManager* wm = g_Renderer.GetWaterManager();
|
||||
wm->m_Waviness = s.waterwaviness;
|
||||
wm->m_Murkiness = s.watermurkiness;
|
||||
wm->m_WindAngle = s.windangle;
|
||||
if (wm->m_WaterType != *s.watertype)
|
||||
WaterManager& waterManager = g_Renderer.GetWaterManager();
|
||||
waterManager.m_Waviness = s.waterwaviness;
|
||||
waterManager.m_Murkiness = s.watermurkiness;
|
||||
waterManager.m_WindAngle = s.windangle;
|
||||
if (waterManager.m_WaterType != *s.watertype)
|
||||
{
|
||||
wm->m_WaterType = *s.watertype;
|
||||
wm->ReloadWaterNormalTextures();
|
||||
waterManager.m_WaterType = *s.watertype;
|
||||
waterManager.ReloadWaterNormalTextures();
|
||||
}
|
||||
|
||||
#define COLOR(A, B) B = CColor(A->r/255.f, A->g/255.f, A->b/255.f, 1.f)
|
||||
COLOR(s.watercolor, wm->m_WaterColor);
|
||||
COLOR(s.watertint, wm->m_WaterTint);
|
||||
COLOR(s.watercolor, waterManager.m_WaterColor);
|
||||
COLOR(s.watertint, waterManager.m_WaterTint);
|
||||
#undef COLOR
|
||||
|
||||
g_LightEnv.SetRotation(s.sunrotation);
|
||||
@ -125,7 +125,7 @@ void SetSettings(const sEnvironmentSettings& s)
|
||||
CStrW skySet = *s.skyset;
|
||||
if (skySet.length() == 0)
|
||||
skySet = L"default";
|
||||
g_Renderer.GetSkyManager()->SetSkySet(skySet);
|
||||
g_Renderer.GetSkyManager().SetSkySet(skySet);
|
||||
|
||||
g_LightEnv.m_FogFactor = s.fogfactor;
|
||||
g_LightEnv.m_FogMax = s.fogmax;
|
||||
@ -241,7 +241,7 @@ QUERYHANDLER(GetEnvironmentSettings)
|
||||
|
||||
QUERYHANDLER(GetSkySets)
|
||||
{
|
||||
std::vector<CStrW> skies = g_Renderer.GetSkyManager()->GetSkySets();
|
||||
std::vector<CStrW> skies = g_Renderer.GetSkyManager().GetSkySets();
|
||||
msg->skysets = std::vector<std::wstring>(skies.begin(), skies.end());
|
||||
}
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2021 Wildfire Games.
|
||||
/* Copyright (C) 2022 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
@ -225,7 +225,7 @@ MESSAGEHANDLER(SaveMap)
|
||||
VfsPath pathname = VfsPath(*msg->filename).ChangeExtension(L".pmp");
|
||||
writer.SaveMap(pathname,
|
||||
g_Game->GetWorld()->GetTerrain(),
|
||||
g_Renderer.GetWaterManager(), g_Renderer.GetSkyManager(),
|
||||
&g_Renderer.GetWaterManager(), &g_Renderer.GetSkyManager(),
|
||||
&g_LightEnv, g_Game->GetView()->GetCamera(), g_Game->GetView()->GetCinema(),
|
||||
&g_Renderer.GetPostprocManager(),
|
||||
g_Game->GetSimulation2());
|
||||
@ -297,7 +297,7 @@ QUERYHANDLER(RasterizeMinimap)
|
||||
|
||||
ssize_t w = dimension;
|
||||
ssize_t h = dimension;
|
||||
float waterHeight = g_Renderer.GetWaterManager()->m_WaterHeight;
|
||||
const float waterHeight = g_Renderer.GetWaterManager().m_WaterHeight;
|
||||
|
||||
for (ssize_t j = 0; j < h; ++j)
|
||||
{
|
||||
|
Loading…
Reference in New Issue
Block a user