sera/0ad
1
0
Fork 0
forked from 0ad/0ad
Code Pull Requests Activity

Unifies providing SkyManager and WaterManager like other managers, refs b889826a3d.

Browse Source 
This was SVN commit r26158.
This commit is contained in:
Vladislav Belov 2022-01-03 10:49:12 +00:00
parent 7afe489214
commit 4fba543488
17 changed files with 134 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
source/graphics/Camera.cpp
View File

@ -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 );

6
source/graphics/CameraController.cpp
View File

@ -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);

6
source/graphics/GameView.cpp
View File

@ -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)

6
source/graphics/MiniMapTexture.cpp
View File

@ -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)

4
source/gui/ObjectTypes/CMiniMap.cpp
View File

@ -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 = {

4
source/ps/Game.cpp
View File

@ -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);

16
source/ps/World.cpp
View File

@ -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,

10
source/renderer/ModelRenderer.cpp
View File

@ -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());
}
}

10
source/renderer/PatchRData.cpp
View File

@ -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();

30
source/renderer/Renderer.cpp
View File

@ -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()

15
source/renderer/Renderer.h
View File

@ -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.
*/

92
source/renderer/TerrainRenderer.cpp
View File

@ -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);

4
source/simulation2/components/CCmpTerrain.cpp
View File

@ -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);
}

12
source/simulation2/components/CCmpWaterManager.cpp
View File

@ -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

12
source/tools/atlas/GameInterface/ActorViewer.cpp
View File

@ -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;
}
}

40
source/tools/atlas/GameInterface/Handlers/EnvironmentHandlers.cpp
View File

@ -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());
}

6
source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp
View File

@ -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)
{