2022-01-03 11:49:12 +01:00
|
|
|
/* Copyright (C) 2022 Wildfire Games.
|
2009-04-18 19:00:33 +02:00
|
|
|
* This file is part of 0 A.D.
|
|
|
|
*
|
|
|
|
* 0 A.D. is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* 0 A.D. is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2006-01-07 02:04:26 +01:00
|
|
|
#include "precompiled.h"
|
|
|
|
|
2021-05-01 18:59:42 +02:00
|
|
|
#include "renderer/TerrainRenderer.h"
|
|
|
|
|
2006-01-07 02:04:26 +01:00
|
|
|
#include "graphics/Camera.h"
|
2021-05-30 21:10:10 +02:00
|
|
|
#include "graphics/Canvas2D.h"
|
2011-03-13 20:22:05 +01:00
|
|
|
#include "graphics/Decal.h"
|
2021-05-01 18:59:42 +02:00
|
|
|
#include "graphics/GameView.h"
|
2006-02-13 15:18:20 +01:00
|
|
|
#include "graphics/LightEnv.h"
|
2011-02-03 02:12:24 +01:00
|
|
|
#include "graphics/LOSTexture.h"
|
2006-01-07 02:04:26 +01:00
|
|
|
#include "graphics/Patch.h"
|
2011-03-13 20:22:05 +01:00
|
|
|
#include "graphics/Model.h"
|
2011-03-26 21:17:21 +01:00
|
|
|
#include "graphics/ShaderManager.h"
|
2011-07-20 21:48:06 +02:00
|
|
|
#include "graphics/TerritoryTexture.h"
|
2012-02-12 21:45:31 +01:00
|
|
|
#include "graphics/TextRenderer.h"
|
2022-02-13 20:30:28 +01:00
|
|
|
#include "graphics/TextureManager.h"
|
2006-01-07 02:04:26 +01:00
|
|
|
#include "maths/MathUtil.h"
|
2009-03-24 22:00:41 +01:00
|
|
|
#include "ps/CLogger.h"
|
2021-05-18 13:09:54 +02:00
|
|
|
#include "ps/CStrInternStatic.h"
|
2021-05-01 18:59:42 +02:00
|
|
|
#include "ps/Filesystem.h"
|
2006-01-07 02:04:26 +01:00
|
|
|
#include "ps/Game.h"
|
|
|
|
#include "ps/Profile.h"
|
2007-01-13 23:44:42 +01:00
|
|
|
#include "ps/World.h"
|
2022-05-09 00:02:46 +02:00
|
|
|
#include "renderer/backend/IDevice.h"
|
2011-03-13 20:22:05 +01:00
|
|
|
#include "renderer/DecalRData.h"
|
2006-01-07 02:04:26 +01:00
|
|
|
#include "renderer/PatchRData.h"
|
|
|
|
#include "renderer/Renderer.h"
|
2019-08-04 10:28:30 +02:00
|
|
|
#include "renderer/RenderingOptions.h"
|
2022-01-04 14:29:01 +01:00
|
|
|
#include "renderer/SceneRenderer.h"
|
2006-02-11 19:04:32 +01:00
|
|
|
#include "renderer/ShadowMap.h"
|
2021-05-01 18:59:42 +02:00
|
|
|
#include "renderer/SkyManager.h"
|
2011-03-13 20:22:05 +01:00
|
|
|
#include "renderer/VertexArray.h"
|
2006-01-07 02:04:26 +01:00
|
|
|
#include "renderer/WaterManager.h"
|
|
|
|
|
|
|
|
/**
|
|
|
|
* TerrainRenderer keeps track of which phase it is in, to detect
|
|
|
|
* when Submit, PrepareForRendering etc. are called in the wrong order.
|
|
|
|
*/
|
2022-01-06 23:44:54 +01:00
|
|
|
enum Phase
|
|
|
|
{
|
2006-01-07 02:04:26 +01:00
|
|
|
Phase_Submit,
|
|
|
|
Phase_Render
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Struct TerrainRendererInternals: Internal variables used by the TerrainRenderer class.
|
|
|
|
*/
|
|
|
|
struct TerrainRendererInternals
|
|
|
|
{
|
|
|
|
/// Which phase (submitting or rendering patches) are we in right now?
|
|
|
|
Phase phase;
|
|
|
|
|
2011-03-13 20:22:05 +01:00
|
|
|
/// Patches that were submitted for this frame
|
2022-01-04 14:29:01 +01:00
|
|
|
std::vector<CPatchRData*> visiblePatches[CSceneRenderer::CULL_MAX];
|
2011-03-13 20:22:05 +01:00
|
|
|
|
|
|
|
/// Decals that were submitted for this frame
|
2022-01-04 14:29:01 +01:00
|
|
|
std::vector<CDecalRData*> visibleDecals[CSceneRenderer::CULL_MAX];
|
2006-05-25 07:46:17 +02:00
|
|
|
|
|
|
|
/// Fancy water shader
|
2021-11-27 16:01:14 +01:00
|
|
|
CShaderTechniquePtr fancyWaterTech;
|
2012-09-28 20:20:36 +02:00
|
|
|
|
|
|
|
CSimulation2* simulation;
|
2006-01-07 02:04:26 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
// Construction/Destruction
|
|
|
|
TerrainRenderer::TerrainRenderer()
|
|
|
|
{
|
|
|
|
m = new TerrainRendererInternals();
|
|
|
|
m->phase = Phase_Submit;
|
|
|
|
}
|
|
|
|
|
|
|
|
TerrainRenderer::~TerrainRenderer()
|
|
|
|
{
|
|
|
|
delete m;
|
|
|
|
}
|
|
|
|
|
2012-09-28 20:20:36 +02:00
|
|
|
void TerrainRenderer::SetSimulation(CSimulation2* simulation)
|
|
|
|
{
|
|
|
|
m->simulation = simulation;
|
|
|
|
}
|
2006-01-07 02:04:26 +01:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
// Submit a patch for rendering
|
2014-06-25 03:11:10 +02:00
|
|
|
void TerrainRenderer::Submit(int cullGroup, CPatch* patch)
|
2006-01-07 02:04:26 +01:00
|
|
|
{
|
2011-04-30 15:01:45 +02:00
|
|
|
ENSURE(m->phase == Phase_Submit);
|
2006-01-07 02:04:26 +01:00
|
|
|
|
2011-03-13 20:22:05 +01:00
|
|
|
CPatchRData* data = (CPatchRData*)patch->GetRenderData();
|
2006-01-07 02:04:26 +01:00
|
|
|
if (data == 0)
|
|
|
|
{
|
|
|
|
// no renderdata for patch, create it now
|
2012-09-28 20:20:36 +02:00
|
|
|
data = new CPatchRData(patch, m->simulation);
|
2006-01-07 02:04:26 +01:00
|
|
|
patch->SetRenderData(data);
|
|
|
|
}
|
2012-09-28 20:20:36 +02:00
|
|
|
data->Update(m->simulation);
|
2006-01-07 02:04:26 +01:00
|
|
|
|
2014-06-25 03:11:10 +02:00
|
|
|
m->visiblePatches[cullGroup].push_back(data);
|
2006-01-07 02:04:26 +01:00
|
|
|
}
|
|
|
|
|
2011-03-13 20:22:05 +01:00
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
// Submit a decal for rendering
|
2014-06-25 03:11:10 +02:00
|
|
|
void TerrainRenderer::Submit(int cullGroup, CModelDecal* decal)
|
2011-03-13 20:22:05 +01:00
|
|
|
{
|
2011-04-30 15:01:45 +02:00
|
|
|
ENSURE(m->phase == Phase_Submit);
|
2011-03-13 20:22:05 +01:00
|
|
|
|
|
|
|
CDecalRData* data = (CDecalRData*)decal->GetRenderData();
|
|
|
|
if (data == 0)
|
|
|
|
{
|
|
|
|
// no renderdata for decal, create it now
|
2012-09-28 20:20:36 +02:00
|
|
|
data = new CDecalRData(decal, m->simulation);
|
2011-03-13 20:22:05 +01:00
|
|
|
decal->SetRenderData(data);
|
|
|
|
}
|
2012-09-28 20:20:36 +02:00
|
|
|
data->Update(m->simulation);
|
2011-03-13 20:22:05 +01:00
|
|
|
|
2014-06-25 03:11:10 +02:00
|
|
|
m->visibleDecals[cullGroup].push_back(data);
|
2011-03-13 20:22:05 +01:00
|
|
|
}
|
2006-01-07 02:04:26 +01:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
// Prepare for rendering
|
|
|
|
void TerrainRenderer::PrepareForRendering()
|
|
|
|
{
|
2011-04-30 15:01:45 +02:00
|
|
|
ENSURE(m->phase == Phase_Submit);
|
2006-01-07 02:04:26 +01:00
|
|
|
|
|
|
|
m->phase = Phase_Render;
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
// Clear submissions lists
|
|
|
|
void TerrainRenderer::EndFrame()
|
|
|
|
{
|
2011-04-30 15:01:45 +02:00
|
|
|
ENSURE(m->phase == Phase_Render || m->phase == Phase_Submit);
|
2006-01-07 02:04:26 +01:00
|
|
|
|
2022-01-04 14:29:01 +01:00
|
|
|
for (int i = 0; i < CSceneRenderer::CULL_MAX; ++i)
|
2011-07-13 01:48:05 +02:00
|
|
|
{
|
2014-06-25 03:11:10 +02:00
|
|
|
m->visiblePatches[i].clear();
|
|
|
|
m->visibleDecals[i].clear();
|
2011-07-13 01:48:05 +02:00
|
|
|
}
|
|
|
|
|
2014-06-25 03:11:10 +02:00
|
|
|
m->phase = Phase_Submit;
|
2011-07-13 01:48:05 +02:00
|
|
|
}
|
|
|
|
|
2022-01-19 18:28:47 +01:00
|
|
|
void TerrainRenderer::RenderTerrainOverlayTexture(
|
2022-05-09 00:02:46 +02:00
|
|
|
Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
|
2022-01-19 18:28:47 +01:00
|
|
|
int cullGroup, CMatrix3D& textureMatrix,
|
2022-05-09 00:02:46 +02:00
|
|
|
Renderer::Backend::ITexture* texture)
|
2012-04-24 18:46:32 +02:00
|
|
|
{
|
|
|
|
ENSURE(m->phase == Phase_Render);
|
|
|
|
|
2014-06-25 03:11:10 +02:00
|
|
|
std::vector<CPatchRData*>& visiblePatches = m->visiblePatches[cullGroup];
|
2012-04-24 18:46:32 +02:00
|
|
|
|
2020-11-09 19:50:40 +01:00
|
|
|
CShaderTechniquePtr debugOverlayTech =
|
|
|
|
g_Renderer.GetShaderManager().LoadEffect(str_debug_overlay);
|
2022-01-19 18:28:47 +01:00
|
|
|
deviceCommandContext->SetGraphicsPipelineState(
|
|
|
|
debugOverlayTech->GetGraphicsPipelineStateDesc());
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->BeginPass();
|
2022-05-02 22:57:22 +02:00
|
|
|
Renderer::Backend::IShaderProgram* debugOverlayShader = debugOverlayTech->GetShader();
|
|
|
|
|
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
debugOverlayShader->GetBindingSlot(str_baseTex), texture);
|
|
|
|
const CMatrix3D transform =
|
|
|
|
g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection();
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
debugOverlayShader->GetBindingSlot(str_transform), transform.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
debugOverlayShader->GetBindingSlot(str_textureTransform), textureMatrix.AsFloatArray());
|
|
|
|
CPatchRData::RenderStreams(deviceCommandContext, visiblePatches, true);
|
2012-04-24 18:46:32 +02:00
|
|
|
|
|
|
|
// To make the overlay visible over water, render an additional map-sized
|
2020-11-09 19:50:40 +01:00
|
|
|
// water-height patch.
|
2012-04-24 18:46:32 +02:00
|
|
|
CBoundingBoxAligned waterBounds;
|
2020-11-09 19:50:40 +01:00
|
|
|
for (CPatchRData* data : visiblePatches)
|
2012-04-24 18:46:32 +02:00
|
|
|
waterBounds += data->GetWaterBounds();
|
|
|
|
if (!waterBounds.IsEmpty())
|
|
|
|
{
|
2020-11-09 19:50:40 +01:00
|
|
|
// Add a delta to avoid z-fighting.
|
2022-01-04 14:29:01 +01:00
|
|
|
const float height = g_Renderer.GetSceneRenderer().GetWaterManager().m_WaterHeight + 0.05f;
|
2022-02-26 01:37:27 +01:00
|
|
|
const float waterPos[] =
|
|
|
|
{
|
2020-11-09 19:50:40 +01:00
|
|
|
waterBounds[0].X, height, waterBounds[0].Z,
|
|
|
|
waterBounds[1].X, height, waterBounds[0].Z,
|
2022-02-26 01:37:27 +01:00
|
|
|
waterBounds[1].X, height, waterBounds[1].Z,
|
|
|
|
waterBounds[0].X, height, waterBounds[0].Z,
|
|
|
|
waterBounds[1].X, height, waterBounds[1].Z,
|
|
|
|
waterBounds[0].X, height, waterBounds[1].Z
|
2012-04-24 18:46:32 +02:00
|
|
|
};
|
2020-11-09 19:50:40 +01:00
|
|
|
|
2022-04-23 22:11:14 +02:00
|
|
|
deviceCommandContext->SetVertexAttributeFormat(
|
|
|
|
Renderer::Backend::VertexAttributeStream::POSITION,
|
|
|
|
Renderer::Backend::Format::R32G32B32_SFLOAT, 0, 0, 0);
|
|
|
|
deviceCommandContext->SetVertexAttributeFormat(
|
|
|
|
Renderer::Backend::VertexAttributeStream::UV0,
|
|
|
|
Renderer::Backend::Format::R32G32B32_SFLOAT, 0, 0, 0);
|
|
|
|
|
|
|
|
deviceCommandContext->SetVertexBufferData(0, waterPos);
|
2020-11-09 19:50:40 +01:00
|
|
|
|
2022-03-03 08:09:59 +01:00
|
|
|
deviceCommandContext->Draw(0, 6);
|
2012-04-24 18:46:32 +02:00
|
|
|
}
|
|
|
|
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->EndPass();
|
2012-04-24 18:46:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-03-26 21:17:21 +01:00
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set up all the uniforms for a shader pass.
|
|
|
|
*/
|
2022-05-02 22:57:22 +02:00
|
|
|
void TerrainRenderer::PrepareShader(
|
2022-05-09 00:02:46 +02:00
|
|
|
Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
|
2022-05-02 22:57:22 +02:00
|
|
|
Renderer::Backend::IShaderProgram* shader, ShadowMap* shadow)
|
2011-03-26 21:17:21 +01:00
|
|
|
{
|
2022-01-04 14:29:01 +01:00
|
|
|
CSceneRenderer& sceneRenderer = g_Renderer.GetSceneRenderer();
|
2012-02-13 15:02:14 +01:00
|
|
|
|
2022-05-02 22:57:22 +02:00
|
|
|
const CMatrix3D transform = sceneRenderer.GetViewCamera().GetViewProjection();
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
shader->GetBindingSlot(str_transform), transform.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
shader->GetBindingSlot(str_cameraPos),
|
|
|
|
sceneRenderer.GetViewCamera().GetOrientation().GetTranslation().AsFloatArray());
|
2022-01-04 14:29:01 +01:00
|
|
|
|
|
|
|
const CLightEnv& lightEnv = sceneRenderer.GetLightEnv();
|
2011-03-26 21:17:21 +01:00
|
|
|
|
|
|
|
if (shadow)
|
2022-05-02 22:57:22 +02:00
|
|
|
shadow->BindTo(deviceCommandContext, shader);
|
2011-03-26 21:17:21 +01:00
|
|
|
|
2022-01-04 14:29:01 +01:00
|
|
|
CLOSTexture& los = sceneRenderer.GetScene().GetLOSTexture();
|
2022-05-02 22:57:22 +02:00
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
shader->GetBindingSlot(str_losTex), los.GetTextureSmooth());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
shader->GetBindingSlot(str_losTransform),
|
|
|
|
los.GetTextureMatrix()[0], los.GetTextureMatrix()[12]);
|
|
|
|
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
shader->GetBindingSlot(str_ambient),
|
|
|
|
lightEnv.m_AmbientColor.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
shader->GetBindingSlot(str_sunColor),
|
|
|
|
lightEnv.m_SunColor.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
shader->GetBindingSlot(str_sunDir),
|
|
|
|
lightEnv.GetSunDir().AsFloatArray());
|
|
|
|
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
shader->GetBindingSlot(str_fogColor),
|
|
|
|
lightEnv.m_FogColor.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
shader->GetBindingSlot(str_fogParams),
|
|
|
|
lightEnv.m_FogFactor, lightEnv.m_FogMax);
|
2011-03-26 21:17:21 +01:00
|
|
|
}
|
|
|
|
|
2022-01-19 18:28:47 +01:00
|
|
|
void TerrainRenderer::RenderTerrainShader(
|
2022-05-09 00:02:46 +02:00
|
|
|
Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
|
2022-01-19 18:28:47 +01:00
|
|
|
const CShaderDefines& context, int cullGroup, ShadowMap* shadow)
|
2011-03-26 21:17:21 +01:00
|
|
|
{
|
2011-04-30 15:01:45 +02:00
|
|
|
ENSURE(m->phase == Phase_Render);
|
2011-03-26 21:17:21 +01:00
|
|
|
|
2014-06-25 03:11:10 +02:00
|
|
|
std::vector<CPatchRData*>& visiblePatches = m->visiblePatches[cullGroup];
|
|
|
|
std::vector<CDecalRData*>& visibleDecals = m->visibleDecals[cullGroup];
|
2011-07-13 01:48:05 +02:00
|
|
|
if (visiblePatches.empty() && visibleDecals.empty())
|
|
|
|
return;
|
|
|
|
|
2011-03-26 21:17:21 +01:00
|
|
|
// render the solid black sides of the map first
|
2021-05-27 22:13:47 +02:00
|
|
|
CShaderTechniquePtr techSolid = g_Renderer.GetShaderManager().LoadEffect(str_solid);
|
2022-01-27 18:25:37 +01:00
|
|
|
Renderer::Backend::GraphicsPipelineStateDesc solidPipelineStateDesc =
|
|
|
|
techSolid->GetGraphicsPipelineStateDesc();
|
|
|
|
solidPipelineStateDesc.rasterizationState.cullMode = Renderer::Backend::CullMode::NONE;
|
|
|
|
deviceCommandContext->SetGraphicsPipelineState(solidPipelineStateDesc);
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->BeginPass();
|
2022-01-19 18:28:47 +01:00
|
|
|
|
2022-05-02 22:57:22 +02:00
|
|
|
Renderer::Backend::IShaderProgram* shaderSolid = techSolid->GetShader();
|
|
|
|
const CMatrix3D transform =
|
|
|
|
g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection();
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
shaderSolid->GetBindingSlot(str_transform), transform.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
shaderSolid->GetBindingSlot(str_color), 0.0f, 0.0f, 0.0f, 1.0f);
|
2012-02-13 15:02:14 +01:00
|
|
|
|
2022-05-02 22:57:22 +02:00
|
|
|
CPatchRData::RenderSides(deviceCommandContext, visiblePatches);
|
2011-03-26 21:17:21 +01:00
|
|
|
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->EndPass();
|
2011-03-26 21:17:21 +01:00
|
|
|
|
2022-01-19 18:28:47 +01:00
|
|
|
CPatchRData::RenderBases(deviceCommandContext, visiblePatches, context, shadow);
|
2011-03-26 21:17:21 +01:00
|
|
|
|
|
|
|
// render blend passes for each patch
|
2022-01-19 18:28:47 +01:00
|
|
|
CPatchRData::RenderBlends(deviceCommandContext, visiblePatches, context, shadow);
|
2011-03-26 21:17:21 +01:00
|
|
|
|
2022-01-19 18:28:47 +01:00
|
|
|
CDecalRData::RenderDecals(deviceCommandContext, visibleDecals, context, shadow);
|
2006-01-07 02:04:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
// Render un-textured patches as polygons
|
2022-01-19 18:28:47 +01:00
|
|
|
void TerrainRenderer::RenderPatches(
|
2022-05-09 00:02:46 +02:00
|
|
|
Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
|
2022-01-27 18:25:37 +01:00
|
|
|
int cullGroup, const CShaderDefines& defines, const CColor& color)
|
2006-01-07 02:04:26 +01:00
|
|
|
{
|
2011-04-30 15:01:45 +02:00
|
|
|
ENSURE(m->phase == Phase_Render);
|
2006-01-07 02:04:26 +01:00
|
|
|
|
2014-06-25 03:11:10 +02:00
|
|
|
std::vector<CPatchRData*>& visiblePatches = m->visiblePatches[cullGroup];
|
2011-07-13 01:48:05 +02:00
|
|
|
if (visiblePatches.empty())
|
|
|
|
return;
|
|
|
|
|
2022-02-25 23:05:06 +01:00
|
|
|
GPU_SCOPED_LABEL(deviceCommandContext, "Render terrain patches");
|
|
|
|
|
2022-01-27 18:25:37 +01:00
|
|
|
CShaderTechniquePtr solidTech = g_Renderer.GetShaderManager().LoadEffect(str_terrain_solid, defines);
|
2022-01-19 18:28:47 +01:00
|
|
|
deviceCommandContext->SetGraphicsPipelineState(
|
2022-01-27 18:25:37 +01:00
|
|
|
solidTech->GetGraphicsPipelineStateDesc());
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->BeginPass();
|
2022-01-19 18:28:47 +01:00
|
|
|
|
2022-05-02 22:57:22 +02:00
|
|
|
Renderer::Backend::IShaderProgram* solidShader = solidTech->GetShader();
|
|
|
|
|
|
|
|
const CMatrix3D transform =
|
|
|
|
g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection();
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
solidShader->GetBindingSlot(str_transform), transform.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
solidShader->GetBindingSlot(str_color), color.AsFloatArray());
|
2012-02-13 15:02:14 +01:00
|
|
|
|
2022-05-02 22:57:22 +02:00
|
|
|
CPatchRData::RenderStreams(deviceCommandContext, visiblePatches, false);
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->EndPass();
|
2006-01-07 02:04:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
// Render outlines of submitted patches as lines
|
2022-02-25 23:05:06 +01:00
|
|
|
void TerrainRenderer::RenderOutlines(
|
2022-05-09 00:02:46 +02:00
|
|
|
Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
|
2022-02-25 23:05:06 +01:00
|
|
|
int cullGroup)
|
2006-01-07 02:04:26 +01:00
|
|
|
{
|
2011-04-30 15:01:45 +02:00
|
|
|
ENSURE(m->phase == Phase_Render);
|
2011-01-30 03:14:44 +01:00
|
|
|
|
2014-06-25 03:11:10 +02:00
|
|
|
std::vector<CPatchRData*>& visiblePatches = m->visiblePatches[cullGroup];
|
2011-07-13 01:48:05 +02:00
|
|
|
if (visiblePatches.empty())
|
|
|
|
return;
|
|
|
|
|
2022-02-25 23:05:06 +01:00
|
|
|
GPU_SCOPED_LABEL(deviceCommandContext, "Render terrain outlines");
|
|
|
|
|
2011-07-13 01:48:05 +02:00
|
|
|
for (size_t i = 0; i < visiblePatches.size(); ++i)
|
|
|
|
visiblePatches[i]->RenderOutline();
|
2006-01-07 02:04:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
2011-07-13 01:48:05 +02:00
|
|
|
// Scissor rectangle of water patches
|
2021-05-01 18:59:42 +02:00
|
|
|
CBoundingBoxAligned TerrainRenderer::ScissorWater(int cullGroup, const CCamera& camera)
|
2006-01-07 02:04:26 +01:00
|
|
|
{
|
2011-11-25 07:36:13 +01:00
|
|
|
CBoundingBoxAligned scissor;
|
2021-05-01 18:59:42 +02:00
|
|
|
for (const CPatchRData* data : m->visiblePatches[cullGroup])
|
2011-07-13 01:48:05 +02:00
|
|
|
{
|
2011-11-25 07:36:13 +01:00
|
|
|
const CBoundingBoxAligned& waterBounds = data->GetWaterBounds();
|
2011-07-13 01:48:05 +02:00
|
|
|
if (waterBounds.IsEmpty())
|
|
|
|
continue;
|
|
|
|
|
2021-05-01 18:59:42 +02:00
|
|
|
const CBoundingBoxAligned waterBoundsInViewPort =
|
|
|
|
camera.GetBoundsInViewPort(waterBounds);
|
|
|
|
if (!waterBoundsInViewPort.IsEmpty())
|
|
|
|
scissor += waterBoundsInViewPort;
|
2011-07-13 01:48:05 +02:00
|
|
|
}
|
2021-05-01 18:59:42 +02:00
|
|
|
return CBoundingBoxAligned(
|
|
|
|
CVector3D(Clamp(scissor[0].X, -1.0f, 1.0f), Clamp(scissor[0].Y, -1.0f, 1.0f), -1.0f),
|
|
|
|
CVector3D(Clamp(scissor[1].X, -1.0f, 1.0f), Clamp(scissor[1].Y, -1.0f, 1.0f), 1.0f));
|
2011-07-13 01:48:05 +02:00
|
|
|
}
|
2010-03-21 15:18:15 +01:00
|
|
|
|
2011-07-13 01:48:05 +02:00
|
|
|
// Render fancy water
|
2022-01-19 18:28:47 +01:00
|
|
|
bool TerrainRenderer::RenderFancyWater(
|
2022-05-09 00:02:46 +02:00
|
|
|
Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
|
2022-01-19 18:28:47 +01:00
|
|
|
const CShaderDefines& context, int cullGroup, ShadowMap* shadow)
|
2011-07-13 01:48:05 +02:00
|
|
|
{
|
2011-11-09 14:09:01 +01:00
|
|
|
PROFILE3_GPU("fancy water");
|
2022-02-18 23:38:45 +01:00
|
|
|
GPU_SCOPED_LABEL(deviceCommandContext, "Render fancy water");
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2022-01-04 14:29:01 +01:00
|
|
|
CSceneRenderer& sceneRenderer = g_Renderer.GetSceneRenderer();
|
|
|
|
|
|
|
|
WaterManager& waterManager = sceneRenderer.GetWaterManager();
|
2012-10-31 19:42:17 +01:00
|
|
|
CShaderDefines defines = context;
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2006-05-25 07:46:17 +02:00
|
|
|
// If we're using fancy water, make sure its shader is loaded
|
2022-01-03 11:49:12 +01:00
|
|
|
if (!m->fancyWaterTech || waterManager.m_NeedsReloading)
|
2006-05-25 07:46:17 +02:00
|
|
|
{
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterRealDepth)
|
2013-09-29 15:19:52 +02:00
|
|
|
defines.Add(str_USE_REAL_DEPTH, str_1);
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterFancyEffects)
|
2014-07-01 18:05:05 +02:00
|
|
|
defines.Add(str_USE_FANCY_EFFECTS, str_1);
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterRefraction)
|
2013-09-29 15:19:52 +02:00
|
|
|
defines.Add(str_USE_REFRACTION, str_1);
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterReflection)
|
2013-09-29 15:19:52 +02:00
|
|
|
defines.Add(str_USE_REFLECTION, str_1);
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2021-12-14 07:34:02 +01:00
|
|
|
m->fancyWaterTech = g_Renderer.GetShaderManager().LoadEffect(str_water_high, defines);
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2021-11-27 16:01:14 +01:00
|
|
|
if (!m->fancyWaterTech)
|
2009-03-24 22:00:41 +01:00
|
|
|
{
|
2021-11-27 16:01:14 +01:00
|
|
|
LOGERROR("Failed to load water shader. Falling back to a simple water.\n");
|
2022-01-03 11:49:12 +01:00
|
|
|
waterManager.m_RenderWater = false;
|
2011-07-13 01:48:05 +02:00
|
|
|
return false;
|
2009-03-24 22:00:41 +01:00
|
|
|
}
|
2022-01-03 11:49:12 +01:00
|
|
|
waterManager.m_NeedsReloading = false;
|
2006-05-25 07:46:17 +02:00
|
|
|
}
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2022-01-04 14:29:01 +01:00
|
|
|
CLOSTexture& losTexture = sceneRenderer.GetScene().GetLOSTexture();
|
2012-10-31 19:42:17 +01:00
|
|
|
|
2012-11-04 16:54:36 +01:00
|
|
|
// Calculating the advanced informations about Foam and all if the quality calls for it.
|
2013-08-18 11:27:11 +02:00
|
|
|
/*if (WaterMgr->m_NeedInfoUpdate && (WaterMgr->m_WaterFoam || WaterMgr->m_WaterCoastalWaves))
|
2013-04-27 14:20:42 +02:00
|
|
|
{
|
2013-08-18 11:27:11 +02:00
|
|
|
WaterMgr->m_NeedInfoUpdate = false;
|
2012-11-04 16:54:36 +01:00
|
|
|
WaterMgr->CreateSuperfancyInfo();
|
2013-04-27 14:20:42 +02:00
|
|
|
}*/
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2022-01-03 11:49:12 +01:00
|
|
|
const double time = waterManager.m_WaterTexTimer;
|
|
|
|
const float repeatPeriod = waterManager.m_RepeatPeriod;
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2022-01-19 18:28:47 +01:00
|
|
|
deviceCommandContext->SetGraphicsPipelineState(
|
|
|
|
m->fancyWaterTech->GetGraphicsPipelineStateDesc());
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->BeginPass();
|
2022-05-02 22:57:22 +02:00
|
|
|
Renderer::Backend::IShaderProgram* fancyWaterShader = m->fancyWaterTech->GetShader();
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2022-01-04 14:29:01 +01:00
|
|
|
const CCamera& camera = g_Renderer.GetSceneRenderer().GetViewCamera();
|
2006-05-25 07:46:17 +02:00
|
|
|
|
2021-12-09 19:01:28 +01:00
|
|
|
const double period = 8.0;
|
2022-02-13 20:30:28 +01:00
|
|
|
// TODO: move uploading to a prepare function during loading.
|
|
|
|
const CTexturePtr& currentNormalTexture = waterManager.m_NormalMap[waterManager.GetCurrentTextureIndex(period)];
|
|
|
|
const CTexturePtr& nextNormalTexture = waterManager.m_NormalMap[waterManager.GetNextTextureIndex(period)];
|
2022-05-02 22:57:22 +02:00
|
|
|
|
2022-02-13 20:30:28 +01:00
|
|
|
currentNormalTexture->UploadBackendTextureIfNeeded(deviceCommandContext);
|
|
|
|
nextNormalTexture->UploadBackendTextureIfNeeded(deviceCommandContext);
|
2022-05-02 22:57:22 +02:00
|
|
|
|
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_normalMap),
|
|
|
|
currentNormalTexture->GetBackendTexture());
|
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_normalMap2),
|
|
|
|
nextNormalTexture->GetBackendTexture());
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterFancyEffects)
|
2014-07-28 12:14:00 +02:00
|
|
|
{
|
2022-05-02 22:57:22 +02:00
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_waterEffectsTex),
|
|
|
|
waterManager.m_FancyTexture.get());
|
2014-07-28 12:14:00 +02:00
|
|
|
}
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterRefraction && waterManager.m_WaterRealDepth)
|
2020-11-11 19:46:52 +01:00
|
|
|
{
|
2022-05-02 22:57:22 +02:00
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_depthTex),
|
|
|
|
waterManager.m_RefrFboDepthTexture.get());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_projInvTransform),
|
|
|
|
waterManager.m_RefractionProjInvMatrix.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_viewInvTransform),
|
|
|
|
waterManager.m_RefractionViewInvMatrix.AsFloatArray());
|
2020-11-11 19:46:52 +01:00
|
|
|
}
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterRefraction)
|
2022-05-02 22:57:22 +02:00
|
|
|
{
|
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_refractionMap),
|
|
|
|
waterManager.m_RefractionTexture.get());
|
|
|
|
}
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterReflection)
|
2022-05-02 22:57:22 +02:00
|
|
|
{
|
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_reflectionMap),
|
|
|
|
waterManager.m_ReflectionTexture.get());
|
|
|
|
}
|
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_losTex), losTexture.GetTextureSmooth());
|
2011-07-13 01:48:05 +02:00
|
|
|
|
2022-01-04 14:29:01 +01:00
|
|
|
const CLightEnv& lightEnv = sceneRenderer.GetLightEnv();
|
2012-10-31 19:42:17 +01:00
|
|
|
|
2022-05-02 22:57:22 +02:00
|
|
|
const CMatrix3D transform = sceneRenderer.GetViewCamera().GetViewProjection();
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_transform), transform.AsFloatArray());
|
2014-07-28 12:14:00 +02:00
|
|
|
|
2022-05-02 22:57:22 +02:00
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_skyCube),
|
|
|
|
sceneRenderer.GetSkyManager().GetSkyCube());
|
2021-03-24 17:40:03 +01:00
|
|
|
// TODO: check that this rotates in the right direction.
|
|
|
|
CMatrix3D skyBoxRotation;
|
|
|
|
skyBoxRotation.SetIdentity();
|
|
|
|
skyBoxRotation.RotateY(M_PI + lightEnv.GetRotation());
|
2022-05-02 22:57:22 +02:00
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_skyBoxRot),
|
|
|
|
skyBoxRotation.AsFloatArray());
|
2021-03-24 17:40:03 +01:00
|
|
|
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterRefraction)
|
2022-05-02 22:57:22 +02:00
|
|
|
{
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_refractionMatrix),
|
|
|
|
waterManager.m_RefractionMatrix.AsFloatArray());
|
|
|
|
}
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterReflection)
|
2022-05-02 22:57:22 +02:00
|
|
|
{
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_reflectionMatrix),
|
|
|
|
waterManager.m_ReflectionMatrix.AsFloatArray());
|
|
|
|
}
|
|
|
|
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_ambient), lightEnv.m_AmbientColor.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_sunDir), lightEnv.GetSunDir().AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_sunColor), lightEnv.m_SunColor.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_color), waterManager.m_WaterColor.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_tint), waterManager.m_WaterTint.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_waviness), waterManager.m_Waviness);
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_murkiness), waterManager.m_Murkiness);
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_windAngle), waterManager.m_WindAngle);
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_repeatScale), 1.0f / repeatPeriod);
|
|
|
|
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_losTransform),
|
|
|
|
losTexture.GetTextureMatrix()[0], losTexture.GetTextureMatrix()[12]);
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_cameraPos),
|
|
|
|
camera.GetOrientation().GetTranslation().AsFloatArray());
|
|
|
|
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_fogColor),
|
|
|
|
lightEnv.m_FogColor.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_fogParams),
|
|
|
|
lightEnv.m_FogFactor, lightEnv.m_FogMax);
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_time), static_cast<float>(time));
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_screenSize),
|
|
|
|
static_cast<float>(g_Renderer.GetWidth()),
|
|
|
|
static_cast<float>(g_Renderer.GetHeight()));
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2022-01-03 11:49:12 +01:00
|
|
|
if (waterManager.m_WaterType == L"clap")
|
2014-07-03 22:07:15 +02:00
|
|
|
{
|
2022-05-02 22:57:22 +02:00
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_waveParams1),
|
|
|
|
30.0f, 1.5f, 20.0f, 0.03f);
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_waveParams2),
|
|
|
|
0.5f, 0.0f, 0.0f, 0.0f);
|
2014-07-28 12:14:00 +02:00
|
|
|
}
|
2022-01-03 11:49:12 +01:00
|
|
|
else if (waterManager.m_WaterType == L"lake")
|
2014-07-28 12:14:00 +02:00
|
|
|
{
|
2022-05-02 22:57:22 +02:00
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_waveParams1),
|
|
|
|
8.5f, 1.5f, 15.0f, 0.03f);
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_waveParams2),
|
|
|
|
0.2f, 0.0f, 0.0f, 0.07f);
|
2014-07-28 12:14:00 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-05-02 22:57:22 +02:00
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_waveParams1),
|
|
|
|
15.0f, 0.8f, 10.0f, 0.1f);
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
fancyWaterShader->GetBindingSlot(str_waveParams2),
|
|
|
|
0.3f, 0.0f, 0.1f, 0.3f);
|
2014-07-03 22:07:15 +02:00
|
|
|
}
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2021-01-15 16:45:39 +01:00
|
|
|
if (shadow)
|
2022-05-02 22:57:22 +02:00
|
|
|
shadow->BindTo(deviceCommandContext, fancyWaterShader);
|
2006-05-25 07:46:17 +02:00
|
|
|
|
2022-01-20 18:31:21 +01:00
|
|
|
for (CPatchRData* data : m->visiblePatches[cullGroup])
|
2006-05-25 07:46:17 +02:00
|
|
|
{
|
2022-05-02 22:57:22 +02:00
|
|
|
data->RenderWaterSurface(deviceCommandContext, true);
|
2022-01-20 18:31:21 +01:00
|
|
|
if (waterManager.m_WaterFancyEffects)
|
2022-05-02 22:57:22 +02:00
|
|
|
data->RenderWaterShore(deviceCommandContext);
|
2006-05-25 07:46:17 +02:00
|
|
|
}
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->EndPass();
|
2006-01-07 02:04:26 +01:00
|
|
|
|
2011-07-13 01:48:05 +02:00
|
|
|
return true;
|
|
|
|
}
|
2006-05-28 04:13:32 +02:00
|
|
|
|
2022-01-19 18:28:47 +01:00
|
|
|
void TerrainRenderer::RenderSimpleWater(
|
2022-05-09 00:02:46 +02:00
|
|
|
Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
|
2022-01-19 18:28:47 +01:00
|
|
|
int cullGroup)
|
2011-07-13 01:48:05 +02:00
|
|
|
{
|
2011-11-09 14:09:01 +01:00
|
|
|
PROFILE3_GPU("simple water");
|
2022-02-18 23:38:45 +01:00
|
|
|
GPU_SCOPED_LABEL(deviceCommandContext, "Render Simple Water");
|
2006-05-25 07:46:17 +02:00
|
|
|
|
2022-01-04 14:29:01 +01:00
|
|
|
const WaterManager& waterManager = g_Renderer.GetSceneRenderer().GetWaterManager();
|
2011-07-13 01:48:05 +02:00
|
|
|
CLOSTexture& losTexture = g_Game->GetView()->GetLOSTexture();
|
|
|
|
|
2022-01-03 11:49:12 +01:00
|
|
|
const double time = waterManager.m_WaterTexTimer;
|
2011-07-13 01:48:05 +02:00
|
|
|
|
2022-02-25 23:05:06 +01:00
|
|
|
CShaderDefines context;
|
|
|
|
if (g_Renderer.GetSceneRenderer().GetWaterRenderMode() == WIREFRAME)
|
|
|
|
context.Add(str_MODE_WIREFRAME, str_1);
|
|
|
|
|
2020-11-04 23:25:08 +01:00
|
|
|
CShaderTechniquePtr waterSimpleTech =
|
2022-02-25 23:05:06 +01:00
|
|
|
g_Renderer.GetShaderManager().LoadEffect(str_water_simple, context);
|
2022-01-19 18:28:47 +01:00
|
|
|
deviceCommandContext->SetGraphicsPipelineState(
|
|
|
|
waterSimpleTech->GetGraphicsPipelineStateDesc());
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->BeginPass();
|
2022-05-02 22:57:22 +02:00
|
|
|
Renderer::Backend::IShaderProgram* waterSimpleShader = waterSimpleTech->GetShader();
|
2020-11-04 23:25:08 +01:00
|
|
|
|
2022-02-13 20:30:28 +01:00
|
|
|
const CTexturePtr& waterTexture = waterManager.m_WaterTexture[waterManager.GetCurrentTextureIndex(1.6)];
|
|
|
|
waterTexture->UploadBackendTextureIfNeeded(deviceCommandContext);
|
2022-05-02 22:57:22 +02:00
|
|
|
|
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
waterSimpleShader->GetBindingSlot(str_baseTex), waterTexture->GetBackendTexture());
|
|
|
|
deviceCommandContext->SetTexture(
|
|
|
|
waterSimpleShader->GetBindingSlot(str_losTex), losTexture.GetTextureSmooth());
|
|
|
|
|
|
|
|
const CMatrix3D transform =
|
|
|
|
g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection();
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
waterSimpleShader->GetBindingSlot(str_transform), transform.AsFloatArray());
|
|
|
|
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
waterSimpleShader->GetBindingSlot(str_losTransform),
|
|
|
|
losTexture.GetTextureMatrix()[0], losTexture.GetTextureMatrix()[12]);
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
waterSimpleShader->GetBindingSlot(str_time), static_cast<float>(time));
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
waterSimpleShader->GetBindingSlot(str_color), waterManager.m_WaterColor.AsFloatArray());
|
2012-02-13 15:02:14 +01:00
|
|
|
|
2014-06-25 03:11:10 +02:00
|
|
|
std::vector<CPatchRData*>& visiblePatches = m->visiblePatches[cullGroup];
|
|
|
|
for (size_t i = 0; i < visiblePatches.size(); ++i)
|
2011-07-13 01:48:05 +02:00
|
|
|
{
|
2014-06-25 03:11:10 +02:00
|
|
|
CPatchRData* data = visiblePatches[i];
|
2022-05-02 22:57:22 +02:00
|
|
|
data->RenderWaterSurface(deviceCommandContext, false);
|
2006-05-28 23:58:56 +02:00
|
|
|
}
|
|
|
|
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->EndPass();
|
2006-01-07 02:04:26 +01:00
|
|
|
}
|
2011-01-29 17:31:48 +01:00
|
|
|
|
2011-07-13 01:48:05 +02:00
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
// Render water that is part of the terrain
|
2022-01-19 18:28:47 +01:00
|
|
|
void TerrainRenderer::RenderWater(
|
2022-05-09 00:02:46 +02:00
|
|
|
Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
|
2022-01-19 18:28:47 +01:00
|
|
|
const CShaderDefines& context, int cullGroup, ShadowMap* shadow)
|
2011-07-13 01:48:05 +02:00
|
|
|
{
|
2022-01-06 23:44:54 +01:00
|
|
|
const WaterManager& waterManager = g_Renderer.GetSceneRenderer().GetWaterManager();
|
2014-07-01 18:05:05 +02:00
|
|
|
|
2022-01-03 11:49:12 +01:00
|
|
|
if (!waterManager.WillRenderFancyWater())
|
2022-01-19 18:28:47 +01:00
|
|
|
RenderSimpleWater(deviceCommandContext, cullGroup);
|
2012-11-04 16:54:36 +01:00
|
|
|
else
|
2022-01-19 18:28:47 +01:00
|
|
|
RenderFancyWater(deviceCommandContext, context, cullGroup, shadow);
|
2011-07-13 01:48:05 +02:00
|
|
|
}
|
|
|
|
|
2022-01-19 18:28:47 +01:00
|
|
|
void TerrainRenderer::RenderWaterFoamOccluders(
|
2022-05-09 00:02:46 +02:00
|
|
|
Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
|
2022-01-19 18:28:47 +01:00
|
|
|
int cullGroup)
|
2022-01-06 23:44:54 +01:00
|
|
|
{
|
|
|
|
CSceneRenderer& sceneRenderer = g_Renderer.GetSceneRenderer();
|
|
|
|
const WaterManager& waterManager = sceneRenderer.GetWaterManager();
|
|
|
|
if (!waterManager.WillRenderFancyWater())
|
|
|
|
return;
|
|
|
|
|
2022-02-18 23:38:45 +01:00
|
|
|
GPU_SCOPED_LABEL(deviceCommandContext, "Render water foam occluders");
|
|
|
|
|
2022-01-06 23:44:54 +01:00
|
|
|
// Render normals and foam to a framebuffer if we're using fancy effects.
|
2022-02-05 17:59:23 +01:00
|
|
|
deviceCommandContext->SetFramebuffer(waterManager.m_FancyEffectsFramebuffer.get());
|
2022-01-06 23:44:54 +01:00
|
|
|
|
|
|
|
// Overwrite waves that would be behind the ground.
|
|
|
|
CShaderTechniquePtr dummyTech = g_Renderer.GetShaderManager().LoadEffect(str_solid);
|
2022-01-27 18:25:37 +01:00
|
|
|
Renderer::Backend::GraphicsPipelineStateDesc pipelineStateDesc =
|
|
|
|
dummyTech->GetGraphicsPipelineStateDesc();
|
2022-02-01 17:38:55 +01:00
|
|
|
pipelineStateDesc.depthStencilState.depthTestEnabled = true;
|
2022-01-27 18:25:37 +01:00
|
|
|
pipelineStateDesc.rasterizationState.cullMode = Renderer::Backend::CullMode::NONE;
|
|
|
|
deviceCommandContext->SetGraphicsPipelineState(pipelineStateDesc);
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->BeginPass();
|
2022-01-06 23:44:54 +01:00
|
|
|
|
2022-05-02 22:57:22 +02:00
|
|
|
Renderer::Backend::IShaderProgram* dummyShader = dummyTech->GetShader();
|
|
|
|
|
|
|
|
const CMatrix3D transform = sceneRenderer.GetViewCamera().GetViewProjection();
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
dummyShader->GetBindingSlot(str_transform), transform.AsFloatArray());
|
|
|
|
deviceCommandContext->SetUniform(
|
|
|
|
dummyShader->GetBindingSlot(str_color), 0.0f, 0.0f, 0.0f, 0.0f);
|
|
|
|
|
2022-01-06 23:44:54 +01:00
|
|
|
for (CPatchRData* data : m->visiblePatches[cullGroup])
|
2022-05-02 22:57:22 +02:00
|
|
|
data->RenderWaterShore(deviceCommandContext);
|
|
|
|
|
2022-03-14 23:16:14 +01:00
|
|
|
deviceCommandContext->EndPass();
|
2022-01-06 23:44:54 +01:00
|
|
|
|
2022-02-05 17:59:23 +01:00
|
|
|
deviceCommandContext->SetFramebuffer(
|
|
|
|
deviceCommandContext->GetDevice()->GetCurrentBackbuffer());
|
2022-01-06 23:44:54 +01:00
|
|
|
}
|
|
|
|
|
2022-02-25 09:14:11 +01:00
|
|
|
void TerrainRenderer::RenderPriorities(CCanvas2D& canvas, int cullGroup)
|
2011-01-29 17:31:48 +01:00
|
|
|
{
|
2011-11-09 14:09:01 +01:00
|
|
|
PROFILE("priorities");
|
2011-01-29 17:31:48 +01:00
|
|
|
|
2011-04-30 15:01:45 +02:00
|
|
|
ENSURE(m->phase == Phase_Render);
|
2011-01-30 03:14:44 +01:00
|
|
|
|
2021-05-30 20:28:06 +02:00
|
|
|
CTextRenderer textRenderer;
|
2021-06-02 23:21:28 +02:00
|
|
|
textRenderer.SetCurrentFont(CStrIntern("mono-stroke-10"));
|
|
|
|
textRenderer.SetCurrentColor(CColor(1.0f, 1.0f, 0.0f, 1.0f));
|
2011-01-29 17:31:48 +01:00
|
|
|
|
2014-06-25 03:11:10 +02:00
|
|
|
std::vector<CPatchRData*>& visiblePatches = m->visiblePatches[cullGroup];
|
|
|
|
for (size_t i = 0; i < visiblePatches.size(); ++i)
|
|
|
|
visiblePatches[i]->RenderPriorities(textRenderer);
|
2012-02-12 21:45:31 +01:00
|
|
|
|
2021-05-30 21:10:10 +02:00
|
|
|
canvas.DrawText(textRenderer);
|
2011-01-29 17:31:48 +01:00
|
|
|
}
|