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

Refactor renderer options.

Browse Source 
This moves the renderer options into their own class to:@
  - allow one to only include the rendering options, not the whole
renderer header, when one wants access to rendering options.
  - centralise rendering changes and their side-effects.
  - clean up code.

Tested by: historic_bruno, Freagarach
Commented by: historic_bruno
Differential Revision: https://code.wildfiregames.com/D1929
This was SVN commit r22610.
This commit is contained in:
wraitii 2019-08-04 08:28:30 +00:00
parent 2ff8614ce2
commit 5c4d124d2a
25 changed files with 408 additions and 400 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
binaries/data/mods/public/gui/options/options.json
View File

@ -115,7 +115,7 @@
"label": "Post Processing",
"tooltip": "Use screen-space postprocessing filters (HDR, Bloom, DOF, etc).",
"config": "postproc",
"function": "Renderer_SetPostprocEnabled"
"function": "Renderer_SetPostProcEnabled"
},
{
"type": "slider",

13
source/graphics/LOSTexture.cpp
View File

@ -27,6 +27,7 @@
#include "ps/Game.h"
#include "ps/Profile.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
#include "renderer/TimeManager.h"
#include "simulation2/Simulation2.h"
#include "simulation2/components/ICmpRangeManager.h"
@ -63,7 +64,7 @@ CLOSTexture::CLOSTexture(CSimulation2& simulation)
m_Texture(0), m_TextureSmooth1(0), m_TextureSmooth2(0), m_smoothFbo(0),
m_MapSize(0), m_TextureSize(0), whichTex(true)
{
if (CRenderer::IsInitialised() && g_Renderer.m_Options.m_SmoothLOS)
if (CRenderer::IsInitialised() && g_RenderingOptions.GetSmoothLOS())
CreateShader();
}
@ -84,7 +85,7 @@ bool CLOSTexture::CreateShader()
if (!m_ShaderInitialized)
{
LOGERROR("Failed to load SmoothLOS shader, disabling.");
g_Renderer.m_Options.m_SmoothLOS = false;
g_RenderingOptions.SetSmoothLOS(false);
return false;
}
@ -125,7 +126,7 @@ void CLOSTexture::BindTexture(int unit)
GLuint CLOSTexture::GetTextureSmooth()
{
if (CRenderer::IsInitialised() && !g_Renderer.m_Options.m_SmoothLOS)
if (CRenderer::IsInitialised() && !g_RenderingOptions.GetSmoothLOS())
return GetTexture();
else
return whichTex ? m_TextureSmooth1 : m_TextureSmooth2;
@ -133,7 +134,7 @@ GLuint CLOSTexture::GetTextureSmooth()
void CLOSTexture::InterpolateLOS()
{
if (CRenderer::IsInitialised() && !g_Renderer.m_Options.m_SmoothLOS)
if (CRenderer::IsInitialised() && !g_RenderingOptions.GetSmoothLOS())
return;
if (!m_ShaderInitialized)
@ -259,7 +260,7 @@ void CLOSTexture::ConstructTexture(int unit)
u8* texData = new u8[m_TextureSize * m_TextureSize * 4];
memset(texData, 0x00, m_TextureSize * m_TextureSize * 4);
if (CRenderer::IsInitialised() && g_Renderer.m_Options.m_SmoothLOS)
if (CRenderer::IsInitialised() && g_RenderingOptions.GetSmoothLOS())
{
glGenTextures(1, &m_TextureSmooth1);
glGenTextures(1, &m_TextureSmooth2);
@ -347,7 +348,7 @@ void CLOSTexture::RecomputeTexture(int unit)
GenerateBitmap(los, &losData[0], m_MapSize, m_MapSize, pitch);
if (CRenderer::IsInitialised() && g_Renderer.m_Options.m_SmoothLOS && recreated)
if (CRenderer::IsInitialised() && g_RenderingOptions.GetSmoothLOS() && recreated)
{
g_Renderer.BindTexture(unit, m_TextureSmooth1);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, pitch, m_MapSize, GL_ALPHA, GL_UNSIGNED_BYTE, &losData[0]);

6
source/graphics/MaterialManager.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2018 Wildfire Games.
/* Copyright (C) 2019 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -27,7 +27,7 @@
#include "ps/Filesystem.h"
#include "ps/PreprocessorWrapper.h"
#include "ps/XML/Xeromyces.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
#include <sstream>
@ -79,7 +79,7 @@ CMaterial CMaterialManager::LoadMaterial(const VfsPath& pathname)
#undef EL
CPreprocessorWrapper preprocessor;
preprocessor.AddDefine("CFG_FORCE_ALPHATEST", g_Renderer.m_Options.m_ForceAlphaTest ? "1" : "0");
preprocessor.AddDefine("CFG_FORCE_ALPHATEST", g_RenderingOptions.GetForceAlphaTest() ? "1" : "0");
CMaterial material;
material.AddStaticUniform("qualityLevel", CVector4D(qualityLevel, 0, 0, 0));

10
source/graphics/Model.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2016 Wildfire Games.
/* Copyright (C) 2019 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -37,7 +37,7 @@
#include "lib/sysdep/rtl.h"
#include "ps/Profile.h"
#include "ps/CLogger.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
#include "simulation2/Simulation2.h"
#include "simulation2/components/ICmpTerrain.h"
@ -362,12 +362,12 @@ void CModel::ValidatePosition()
// per-vertex work is a single matrix*vec multiplication.
// For GPU skinning, we try to minimise CPU work by doing most computation
// in the vertex shader instead.
// Using g_Renderer.m_Options to detect CPU vs GPU is a bit hacky,
// Using g_RenderingOptions to detect CPU vs GPU is a bit hacky,
// and this doesn't allow the setting to change at runtime, but there isn't
// an obvious cleaner way to determine what data needs to be computed,
// and GPU skinning is a rarely-used experimental feature anyway.
bool worldSpaceBoneMatrices = !g_Renderer.m_Options.m_GPUSkinning;
bool computeBlendMatrices = !g_Renderer.m_Options.m_GPUSkinning;
bool worldSpaceBoneMatrices = !g_RenderingOptions.GetGPUSkinning();
bool computeBlendMatrices = !g_RenderingOptions.GetGPUSkinning();
if (m_BoneMatrices && worldSpaceBoneMatrices)
{

5
source/gui/MiniMap.cpp
View File

@ -43,6 +43,7 @@
#include "ps/World.h"
#include "ps/XML/Xeromyces.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
#include "renderer/WaterManager.h"
#include "scriptinterface/ScriptInterface.h"
#include "simulation2/Simulation2.h"
@ -574,7 +575,7 @@ void CMiniMap::Draw()
if (m_EntitiesDrawn > 0)
{
#if !CONFIG2_GLES
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
#endif
@ -593,7 +594,7 @@ void CMiniMap::Draw()
CVertexBuffer::Unbind();
#if !CONFIG2_GLES
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
glDisable(GL_VERTEX_PROGRAM_POINT_SIZE);
#endif
}

5
source/ps/GameSetup/Config.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2017 Wildfire Games.
/* Copyright (C) 2019 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -37,8 +37,6 @@ bool g_NoGLVBO = false;
bool g_PauseOnFocusLoss = false;
bool g_RenderActors = true;
bool g_Shadows = false;
bool g_ShadowPCF = false;
@ -93,7 +91,6 @@ static void LoadGlobals()
CFG_GET_VAL("noautomipmap", g_NoGLAutoMipmap);
CFG_GET_VAL("novbo", g_NoGLVBO);
CFG_GET_VAL("pauseonfocusloss", g_PauseOnFocusLoss);
CFG_GET_VAL("renderactors", g_RenderActors);
CFG_GET_VAL("shadows", g_Shadows);
CFG_GET_VAL("shadowpcf", g_ShadowPCF);

5
source/ps/GameSetup/Config.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2017 Wildfire Games.
/* Copyright (C) 2019 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -44,9 +44,6 @@ extern bool g_NoGLVBO;
// flag to pause the game on window focus loss
extern bool g_PauseOnFocusLoss;
// flag to switch on actor rendering
extern bool g_RenderActors;
// flag to switch on shadows
extern bool g_Shadows;

36
source/ps/GameSetup/GameSetup.cpp
View File

@ -595,41 +595,43 @@ static void InitRenderer()
// create renderer
new CRenderer;
g_RenderingOptions.ReadConfig();
// set renderer options from command line options - NOVBO must be set before opening the renderer
// and init them in the ConfigDB when needed
g_Renderer.SetOptionBool(CRenderer::OPT_NOVBO, g_NoGLVBO);
g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWS, g_Shadows);
g_RenderingOptions.SetNoVBO(g_NoGLVBO);
g_RenderingOptions.SetShadows(g_Shadows);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "shadows", g_Shadows);
g_Renderer.SetOptionBool(CRenderer::OPT_WATEREFFECTS, g_WaterEffects);
g_RenderingOptions.SetWaterEffects(g_WaterEffects);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "watereffects", g_WaterEffects);
g_Renderer.SetOptionBool(CRenderer::OPT_WATERFANCYEFFECTS, g_WaterFancyEffects);
g_RenderingOptions.SetWaterFancyEffects(g_WaterFancyEffects);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterfancyeffects", g_WaterFancyEffects);
g_Renderer.SetOptionBool(CRenderer::OPT_WATERREALDEPTH, g_WaterRealDepth);
g_RenderingOptions.SetWaterRealDepth(g_WaterRealDepth);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterrealdepth", g_WaterRealDepth);
g_Renderer.SetOptionBool(CRenderer::OPT_WATERREFLECTION, g_WaterReflection);
g_RenderingOptions.SetWaterReflection(g_WaterReflection);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterreflection", g_WaterReflection);
g_Renderer.SetOptionBool(CRenderer::OPT_WATERREFRACTION, g_WaterRefraction);
g_RenderingOptions.SetWaterRefraction(g_WaterRefraction);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterrefraction", g_WaterRefraction);
g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWSONWATER, g_WaterShadows);
g_RenderingOptions.SetWaterShadows(g_WaterShadows);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "watershadows", g_WaterShadows);
g_Renderer.SetRenderPath(CRenderer::GetRenderPathByName(g_RenderPath));
g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWPCF, g_ShadowPCF);
g_RenderingOptions.SetRenderPath(RenderPathEnum::FromString(g_RenderPath));
g_RenderingOptions.SetShadowPCF(g_ShadowPCF);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "shadowpcf", g_ShadowPCF);
g_Renderer.SetOptionBool(CRenderer::OPT_PARTICLES, g_Particles);
g_RenderingOptions.SetParticles(g_Particles);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "particles", g_Particles);
g_Renderer.SetOptionBool(CRenderer::OPT_FOG, g_Fog);
g_RenderingOptions.SetFog(g_Fog);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "fog", g_Fog);
g_Renderer.SetOptionBool(CRenderer::OPT_SILHOUETTES, g_Silhouettes);
g_RenderingOptions.SetSilhouettes(g_Silhouettes);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "silhouettes", g_Silhouettes);
g_Renderer.SetOptionBool(CRenderer::OPT_SHOWSKY, g_ShowSky);
g_RenderingOptions.SetShowSky(g_ShowSky);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "showsky", g_ShowSky);
g_Renderer.SetOptionBool(CRenderer::OPT_PREFERGLSL, g_PreferGLSL);
g_RenderingOptions.SetPreferGLSL(g_PreferGLSL);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "preferglsl", g_PreferGLSL);
g_Renderer.SetOptionBool(CRenderer::OPT_POSTPROC, g_PostProc);
g_RenderingOptions.SetPostProc(g_PostProc);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "postproc", g_PostProc);
g_Renderer.SetOptionBool(CRenderer::OPT_SMOOTHLOS, g_SmoothLOS);
g_RenderingOptions.SetSmoothLOS(g_SmoothLOS);
g_ConfigDB.SetValueBool(CFG_SYSTEM, "smoothlos", g_SmoothLOS);
// create terrain related stuff

4
source/renderer/DecalRData.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2015 Wildfire Games.
/* Copyright (C) 2019 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -217,7 +217,7 @@ void CDecalRData::BuildArrays()
VertexArrayIterator<float[2]> UV = m_UV.GetIterator<float[2]>();
const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
bool cpuLighting = (g_Renderer.GetRenderPath() == CRenderer::RP_FIXED);
bool cpuLighting = (g_RenderingOptions.GetRenderPath() == RenderPath::FIXED);
for (ssize_t j = j0; j <= j1; ++j)
{

18
source/renderer/OverlayRenderer.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2015 Wildfire Games.
/* Copyright (C) 2019 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -419,7 +419,7 @@ void OverlayRenderer::RenderTexturedOverlayLines()
glDepthMask(0);
const char* shaderName;
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
shaderName = "arb/overlayline";
else
shaderName = "fixed:overlayline";
@ -503,7 +503,7 @@ void OverlayRenderer::RenderQuadOverlays()
glDepthMask(0);
const char* shaderName;
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
shaderName = "arb/overlayline";
else
shaderName = "fixed:overlayline";
@ -600,7 +600,7 @@ void OverlayRenderer::RenderForegroundOverlays(const CCamera& viewCamera)
CShaderProgramPtr shader;
CShaderTechniquePtr tech;
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
{
tech = g_Renderer.GetShaderManager().LoadEffect(str_foreground_overlay);
tech->BeginPass();
@ -609,7 +609,7 @@ void OverlayRenderer::RenderForegroundOverlays(const CCamera& viewCamera)
float uvs[8] = { 0,1, 1,1, 1,0, 0,0 };
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, sizeof(float)*2, &uvs[0]);
else
glTexCoordPointer(2, GL_FLOAT, sizeof(float)*2, &uvs);
@ -618,7 +618,7 @@ void OverlayRenderer::RenderForegroundOverlays(const CCamera& viewCamera)
{
SOverlaySprite* sprite = m->sprites[i];
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
shader->BindTexture(str_baseTex, sprite->m_Texture);
else
sprite->m_Texture->Bind();
@ -632,7 +632,7 @@ void OverlayRenderer::RenderForegroundOverlays(const CCamera& viewCamera)
sprite->m_Position + right*sprite->m_X0 + up*sprite->m_Y1
};
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
shader->VertexPointer(3, GL_FLOAT, sizeof(float)*3, &pos[0].X);
else
glVertexPointer(3, GL_FLOAT, sizeof(float)*3, &pos[0].X);
@ -643,7 +643,7 @@ void OverlayRenderer::RenderForegroundOverlays(const CCamera& viewCamera)
g_Renderer.GetStats().m_OverlayTris += 2;
}
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
tech->EndPass();
glDisableClientState(GL_VERTEX_ARRAY);
@ -723,7 +723,7 @@ void OverlayRenderer::RenderSphereOverlays()
#if CONFIG2_GLES
#warning TODO: implement OverlayRenderer::RenderSphereOverlays for GLES
#else
if (g_Renderer.GetRenderPath() != CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() != RenderPath::SHADER)
return;
if (m->spheres.empty())

4
source/renderer/ParticleRenderer.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2011 Wildfire Games.
/* Copyright (C) 2019 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -88,7 +88,7 @@ void ParticleRenderer::PrepareForRendering(const CShaderDefines& context)
{
// Only construct the shaders when shaders are supported and enabled; otherwise
// RenderParticles will never be called so it's safe to leave the shaders as null
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
{
m->shader = g_Renderer.GetShaderManager().LoadEffect(str_particle, context, CShaderDefines());
m->shaderSolid = g_Renderer.GetShaderManager().LoadEffect(str_particle_solid, context, CShaderDefines());

4
source/renderer/PatchRData.cpp
View File

@ -370,7 +370,7 @@ void CPatchRData::AddBlend(std::vector<SBlendVertex>& blendVertices, std::vector
const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
CVector3D normal;
bool cpuLighting = (g_Renderer.GetRenderPath() == CRenderer::RP_FIXED);
bool cpuLighting = (g_RenderingOptions.GetRenderPath() == RenderPath::FIXED);
size_t index = blendVertices.size();
@ -545,7 +545,7 @@ void CPatchRData::BuildVertices()
CTerrain* terrain=m_Patch->m_Parent;
const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
bool cpuLighting = (g_Renderer.GetRenderPath() == CRenderer::RP_FIXED);
bool cpuLighting = (g_RenderingOptions.GetRenderPath() == RenderPath::FIXED);
// build vertices
for (ssize_t j=0;j<vsize;j++) {

264
source/renderer/Renderer.cpp
View File

@ -64,6 +64,7 @@
#include "renderer/OverlayRenderer.h"
#include "renderer/ParticleRenderer.h"
#include "renderer/PostprocManager.h"
#include "renderer/RenderingOptions.h"
#include "renderer/RenderModifiers.h"
#include "renderer/ShadowMap.h"
#include "renderer/SilhouetteRenderer.h"
@ -369,7 +370,7 @@ public:
void CallModelRenderers(const CShaderDefines& context, int cullGroup, int flags)
{
CShaderDefines contextSkinned = context;
if (g_Renderer.m_Options.m_GPUSkinning)
if (g_RenderingOptions.GetGPUSkinning())
{
contextSkinned.Add(str_USE_INSTANCING, str_1);
contextSkinned.Add(str_USE_GPU_SKINNING, str_1);
@ -390,7 +391,7 @@ public:
void CallTranspModelRenderers(const CShaderDefines& context, int cullGroup, int flags)
{
CShaderDefines contextSkinned = context;
if (g_Renderer.m_Options.m_GPUSkinning)
if (g_RenderingOptions.GetGPUSkinning())
{
contextSkinned.Add(str_USE_INSTANCING, str_1);
contextSkinned.Add(str_USE_GPU_SKINNING, str_1);
@ -426,36 +427,6 @@ CRenderer::CRenderer()
m_DisplayTerrainPriorities = false;
m_SkipSubmit = false;
m_Options.m_NoVBO = false;
m_Options.m_RenderPath = RP_DEFAULT;
m_Options.m_Shadows = false;
m_Options.m_WaterEffects = false;
m_Options.m_WaterFancyEffects = false;
m_Options.m_WaterRealDepth = false;
m_Options.m_WaterRefraction = false;
m_Options.m_WaterReflection = false;
m_Options.m_WaterShadows = false;
m_Options.m_ShadowAlphaFix = true;
m_Options.m_ARBProgramShadow = true;
m_Options.m_ShadowPCF = false;
m_Options.m_Particles = false;
m_Options.m_Silhouettes = false;
m_Options.m_PreferGLSL = false;
m_Options.m_Fog = false;
m_Options.m_ForceAlphaTest = false;
m_Options.m_GPUSkinning = false;
m_Options.m_SmoothLOS = false;
m_Options.m_Postproc = false;
m_Options.m_ShowSky = false;
m_Options.m_DisplayFrustum = false;
// TODO: be more consistent in use of the config system
CFG_GET_VAL("preferglsl", m_Options.m_PreferGLSL);
CFG_GET_VAL("forcealphatest", m_Options.m_ForceAlphaTest);
CFG_GET_VAL("gpuskinning", m_Options.m_GPUSkinning);
CFG_GET_VAL("smoothlos", m_Options.m_SmoothLOS);
CFG_GET_VAL("postproc", m_Options.m_Postproc);
CStr skystring = "0 0 0";
CColor skycolor;
CFG_GET_VAL("skycolor", skystring);
@ -464,7 +435,7 @@ CRenderer::CRenderer()
#if CONFIG2_GLES
// Override config option since GLES only supports GLSL
m_Options.m_PreferGLSL = true;
g_RenderingOptions.GetPreferGLSL() = true;
#endif
m_ShadowZBias = 0.02f;
@ -508,7 +479,7 @@ void CRenderer::EnumCaps()
m_Caps.m_PrettyWater = false;
// now start querying extensions
if (!m_Options.m_NoVBO && ogl_HaveExtension("GL_ARB_vertex_buffer_object"))
if (!g_RenderingOptions.GetNoVBO() && ogl_HaveExtension("GL_ARB_vertex_buffer_object"))
m_Caps.m_VBO = true;
if (0 == ogl_HaveExtensions(0, "GL_ARB_vertex_program", "GL_ARB_fragment_program", NULL))
@ -548,13 +519,13 @@ void CRenderer::RecomputeSystemShaderDefines()
{
CShaderDefines defines;
if (GetRenderPath() == RP_SHADER && m_Caps.m_ARBProgram)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER && m_Caps.m_ARBProgram)
defines.Add(str_SYS_HAS_ARB, str_1);
if (GetRenderPath() == RP_SHADER && m_Caps.m_VertexShader && m_Caps.m_FragmentShader)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER && m_Caps.m_VertexShader && m_Caps.m_FragmentShader)
defines.Add(str_SYS_HAS_GLSL, str_1);
if (m_Options.m_PreferGLSL)
if (g_RenderingOptions.GetPreferGLSL())
defines.Add(str_SYS_PREFER_GLSL, str_1);
m_SystemShaderDefines = defines;
@ -566,30 +537,30 @@ void CRenderer::ReloadShaders()
m->globalContext = m_SystemShaderDefines;
if (m_Caps.m_Shadows && m_Options.m_Shadows)
if (m_Caps.m_Shadows && g_RenderingOptions.GetShadows())
{
m->globalContext.Add(str_USE_SHADOW, str_1);
if (m_Caps.m_ARBProgramShadow && m_Options.m_ARBProgramShadow)
if (m_Caps.m_ARBProgramShadow && g_RenderingOptions.GetARBProgramShadow())
m->globalContext.Add(str_USE_FP_SHADOW, str_1);
if (m_Options.m_ShadowPCF)
if (g_RenderingOptions.GetShadowPCF())
m->globalContext.Add(str_USE_SHADOW_PCF, str_1);
#if !CONFIG2_GLES
m->globalContext.Add(str_USE_SHADOW_SAMPLER, str_1);
#endif
}
if (m_Options.m_PreferGLSL && m_Options.m_Fog)
if (g_RenderingOptions.GetPreferGLSL() && g_RenderingOptions.GetFog())
m->globalContext.Add(str_USE_FOG, str_1);
m->Model.ModShader = LitRenderModifierPtr(new ShaderRenderModifier());
bool cpuLighting = (GetRenderPath() == RP_FIXED);
bool cpuLighting = (g_RenderingOptions.GetRenderPath() == RenderPath::FIXED);
m->Model.VertexRendererShader = ModelVertexRendererPtr(new ShaderModelVertexRenderer(cpuLighting));
m->Model.VertexInstancingShader = ModelVertexRendererPtr(new InstancingModelRenderer(false, m_Options.m_PreferGLSL));
m->Model.VertexInstancingShader = ModelVertexRendererPtr(new InstancingModelRenderer(false, g_RenderingOptions.GetPreferGLSL()));
if (GetRenderPath() == RP_SHADER && m_Options.m_GPUSkinning) // TODO: should check caps and GLSL etc too
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER && g_RenderingOptions.GetGPUSkinning()) // TODO: should check caps and GLSL etc too
{
m->Model.VertexGPUSkinningShader = ModelVertexRendererPtr(new InstancingModelRenderer(true, m_Options.m_PreferGLSL));
m->Model.VertexGPUSkinningShader = ModelVertexRendererPtr(new InstancingModelRenderer(true, g_RenderingOptions.GetPreferGLSL()));
m->Model.NormalSkinned = ModelRendererPtr(new ShaderModelRenderer(m->Model.VertexGPUSkinningShader));
m->Model.TranspSkinned = ModelRendererPtr(new ShaderModelRenderer(m->Model.VertexGPUSkinningShader));
}
@ -601,7 +572,7 @@ void CRenderer::ReloadShaders()
}
// Use instancing renderers in shader mode
if (GetRenderPath() == RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
{
m->Model.NormalUnskinned = ModelRendererPtr(new ShaderModelRenderer(m->Model.VertexInstancingShader));
m->Model.TranspUnskinned = ModelRendererPtr(new ShaderModelRenderer(m->Model.VertexInstancingShader));
@ -647,7 +618,7 @@ bool CRenderer::Open(int width, int height)
LOGMESSAGE("CRenderer::Open: alpha bits %d",bits);
// Validate the currently selected render path
SetRenderPath(m_Options.m_RenderPath);
SetRenderPath(g_RenderingOptions.GetRenderPath());
RecomputeSystemShaderDefines();
@ -655,7 +626,7 @@ bool CRenderer::Open(int width, int height)
// the shader path have been determined.
m->overlayRenderer.Initialize();
if (m_Options.m_Postproc)
if (g_RenderingOptions.GetPostProc())
m->postprocManager.Initialize();
return true;
@ -675,124 +646,6 @@ void CRenderer::Resize(int width, int height)
m_WaterManager->Resize();
}
//////////////////////////////////////////////////////////////////////////////////////////
// SetOptionBool: set boolean renderer option
void CRenderer::SetOptionBool(enum Option opt,bool value)
{
// Don't do anything if the option didn't change from its previous value.
if (value == GetOptionBool(opt))
return;
switch (opt) {
case OPT_NOVBO:
m_Options.m_NoVBO = value;
break;
case OPT_SHADOWS:
m_Options.m_Shadows = value;
MakeShadersDirty();
break;
case OPT_WATEREFFECTS:
m_Options.m_WaterEffects = value;
break;
case OPT_WATERFANCYEFFECTS:
m_Options.m_WaterFancyEffects = value;
break;
case OPT_WATERREALDEPTH:
m_Options.m_WaterRealDepth = value;
break;
case OPT_WATERREFLECTION:
m_Options.m_WaterReflection = value;
break;
case OPT_WATERREFRACTION:
m_Options.m_WaterRefraction = value;
break;
case OPT_SHADOWSONWATER:
m_Options.m_WaterShadows = value;
break;
case OPT_SHADOWPCF:
m_Options.m_ShadowPCF = value;
MakeShadersDirty();
break;
case OPT_PARTICLES:
m_Options.m_Particles = value;
break;
case OPT_PREFERGLSL:
m_Options.m_PreferGLSL = value;
MakeShadersDirty();
RecomputeSystemShaderDefines();
break;
case OPT_FOG:
m_Options.m_Fog = value;
MakeShadersDirty();
break;
case OPT_SILHOUETTES:
m_Options.m_Silhouettes = value;
break;
case OPT_SHOWSKY:
m_Options.m_ShowSky = value;
break;
case OPT_SMOOTHLOS:
m_Options.m_SmoothLOS = value;
break;
case OPT_POSTPROC:
m_Options.m_Postproc = value;
break;
case OPT_DISPLAYFRUSTUM:
m_Options.m_DisplayFrustum = value;
break;
default:
debug_warn(L"CRenderer::SetOptionBool: unknown option");
break;
}
}
//////////////////////////////////////////////////////////////////////////////////////////
// GetOptionBool: get boolean renderer option
bool CRenderer::GetOptionBool(enum Option opt) const
{
switch (opt) {
case OPT_NOVBO:
return m_Options.m_NoVBO;
case OPT_SHADOWS:
return m_Options.m_Shadows;
case OPT_WATEREFFECTS:
return m_Options.m_WaterEffects;
case OPT_WATERFANCYEFFECTS:
return m_Options.m_WaterFancyEffects;
case OPT_WATERREALDEPTH:
return m_Options.m_WaterRealDepth;
case OPT_WATERREFLECTION:
return m_Options.m_WaterReflection;
case OPT_WATERREFRACTION:
return m_Options.m_WaterRefraction;
case OPT_SHADOWSONWATER:
return m_Options.m_WaterShadows;
case OPT_SHADOWPCF:
return m_Options.m_ShadowPCF;
case OPT_PARTICLES:
return m_Options.m_Particles;
case OPT_PREFERGLSL:
return m_Options.m_PreferGLSL;
case OPT_FOG:
return m_Options.m_Fog;
case OPT_SILHOUETTES:
return m_Options.m_Silhouettes;
case OPT_SHOWSKY:
return m_Options.m_ShowSky;
case OPT_SMOOTHLOS:
return m_Options.m_SmoothLOS;
case OPT_POSTPROC:
return m_Options.m_Postproc;
case OPT_DISPLAYFRUSTUM:
return m_Options.m_DisplayFrustum;
default:
debug_warn(L"CRenderer::GetOptionBool: unknown option");
break;
}
return false;
}
//////////////////////////////////////////////////////////////////////////////////////////
// SetRenderPath: Select the preferred render path.
// This may only be called before Open(), because the layout of vertex arrays and other
@ -802,29 +655,29 @@ void CRenderer::SetRenderPath(RenderPath rp)
if (!m->IsOpen)
{
// Delay until Open() is called.
m_Options.m_RenderPath = rp;
return;
}
// Renderer has been opened, so validate the selected renderpath
if (rp == RP_DEFAULT)
if (rp == RenderPath::DEFAULT)
{
if (m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && m_Options.m_PreferGLSL))
rp = RP_SHADER;
if (m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && g_RenderingOptions.GetPreferGLSL()))
rp = RenderPath::SHADER;
else
rp = RP_FIXED;
rp = RenderPath::FIXED;
}
if (rp == RP_SHADER)
if (rp == RenderPath::SHADER)
{
if (!(m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && m_Options.m_PreferGLSL)))
if (!(m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && g_RenderingOptions.GetPreferGLSL())))
{
LOGWARNING("Falling back to fixed function\n");
rp = RP_FIXED;
rp = RenderPath::FIXED;
}
}
m_Options.m_RenderPath = rp;
// TODO: remove this once capabilities have been properly extracted and the above checks have been moved elsewhere.
g_RenderingOptions.m_RenderPath = rp;
MakeShadersDirty();
RecomputeSystemShaderDefines();
@ -834,31 +687,6 @@ void CRenderer::SetRenderPath(RenderPath rp)
g_Game->GetWorld()->GetTerrain()->MakeDirty(RENDERDATA_UPDATE_COLOR);
}
CStr CRenderer::GetRenderPathName(RenderPath rp)
{
switch(rp) {
case RP_DEFAULT: return "default";
case RP_FIXED: return "fixed";
case RP_SHADER: return "shader";
default: return "(invalid)";
}
}
CRenderer::RenderPath CRenderer::GetRenderPathByName(const CStr& name)
{
if (name == "fixed")
return RP_FIXED;
if (name == "shader")
return RP_SHADER;
if (name == "default")
return RP_DEFAULT;
LOGWARNING("Unknown render path name '%s', assuming 'default'", name.c_str());
return RP_DEFAULT;
}
//////////////////////////////////////////////////////////////////////////////////////////
// BeginFrame: signal frame start
void CRenderer::BeginFrame()
@ -943,8 +771,8 @@ void CRenderer::RenderPatches(const CShaderDefines& context, int cullGroup)
#endif
// render all the patches, including blend pass
if (GetRenderPath() == RP_SHADER)
m->terrainRenderer.RenderTerrainShader(context, cullGroup, (m_Caps.m_Shadows && m_Options.m_Shadows) ? &m->shadow : 0);
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
m->terrainRenderer.RenderTerrainShader(context, cullGroup, (m_Caps.m_Shadows && g_RenderingOptions.GetShadows()) ? &m->shadow : 0);
else
m->terrainRenderer.RenderTerrain(cullGroup);
@ -1226,7 +1054,7 @@ void CRenderer::RenderReflections(const CShaderDefines& context, const CBounding
glFrontFace(GL_CW);
if (!m_Options.m_WaterReflection)
if (!g_RenderingOptions.GetWaterReflection())
{
m->skyManager.RenderSky();
ogl_WarnIfError();
@ -1245,7 +1073,7 @@ void CRenderer::RenderReflections(const CShaderDefines& context, const CBounding
// Particles are always oriented to face the camera in the vertex shader,
// so they don't need the inverted glFrontFace
if (m_Options.m_Particles)
if (g_RenderingOptions.GetParticles())
{
RenderParticles(CULL_REFLECTIONS);
ogl_WarnIfError();
@ -1431,7 +1259,7 @@ void CRenderer::RenderSilhouettes(const CShaderDefines& context)
void CRenderer::RenderParticles(int cullGroup)
{
// Only supported in shader modes
if (GetRenderPath() != RP_SHADER)
if (g_RenderingOptions.GetRenderPath() != RenderPath::SHADER)
return;
PROFILE3_GPU("particles");
@ -1471,7 +1299,7 @@ void CRenderer::RenderSubmissions(const CBoundingBoxAligned& waterScissor)
GetScene().GetLOSTexture().InterpolateLOS();
if (m_Options.m_Postproc)
if (g_RenderingOptions.GetPostProc())
{
m->postprocManager.Initialize();
m->postprocManager.CaptureRenderOutput();
@ -1503,7 +1331,7 @@ void CRenderer::RenderSubmissions(const CBoundingBoxAligned& waterScissor)
m->particleRenderer.PrepareForRendering(context);
if (m_Caps.m_Shadows && m_Options.m_Shadows && GetRenderPath() == RP_SHADER)
if (m_Caps.m_Shadows && g_RenderingOptions.GetShadows() && g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
{
RenderShadowMap(context);
}
@ -1523,12 +1351,12 @@ void CRenderer::RenderSubmissions(const CBoundingBoxAligned& waterScissor)
PROFILE3_GPU("water scissor");
RenderReflections(context, waterScissor);
if (m_Options.m_WaterRefraction)
if (g_RenderingOptions.GetWaterRefraction())
RenderRefractions(context, waterScissor);
}
}
if (m_Options.m_ShowSky)
if (g_RenderingOptions.GetShowSky())
{
m->skyManager.RenderSky();
}
@ -1578,19 +1406,19 @@ void CRenderer::RenderSubmissions(const CBoundingBoxAligned& waterScissor)
ogl_WarnIfError();
// particles are transparent so render after water
if (m_Options.m_Particles)
if (g_RenderingOptions.GetParticles())
{
RenderParticles(cullGroup);
ogl_WarnIfError();
}
if (m_Options.m_Postproc)
if (g_RenderingOptions.GetPostProc())
{
m->postprocManager.ApplyPostproc();
m->postprocManager.ReleaseRenderOutput();
}
if (m_Options.m_Silhouettes)
if (g_RenderingOptions.GetSilhouettes())
{
RenderSilhouettes(context);
}
@ -1602,7 +1430,7 @@ void CRenderer::RenderSubmissions(const CBoundingBoxAligned& waterScissor)
#endif
// render debug lines
if (m_Options.m_DisplayFrustum)
if (g_RenderingOptions.GetDisplayFrustum())
{
DisplayFrustum();
m->shadow.RenderDebugBounds();
@ -1701,7 +1529,7 @@ void CRenderer::SetSceneCamera(const CCamera& viewCamera, const CCamera& cullCam
m_ViewCamera = viewCamera;
m_CullCamera = cullCamera;
if (m_Caps.m_Shadows && m_Options.m_Shadows && GetRenderPath() == RP_SHADER)
if (m_Caps.m_Shadows && g_RenderingOptions.GetShadows() && g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
m->shadow.SetupFrame(m_CullCamera, m_LightEnv->GetSunDir());
}
@ -1833,7 +1661,7 @@ void CRenderer::RenderScene(Scene& scene)
m->particleManager.RenderSubmit(*this, frustum);
if (m_Options.m_Silhouettes)
if (g_RenderingOptions.GetSilhouettes())
{
m->silhouetteRenderer.ComputeSubmissions(m_ViewCamera);
@ -1847,7 +1675,7 @@ void CRenderer::RenderScene(Scene& scene)
m->silhouetteRenderer.RenderSubmitCasters(*this);
}
if (m_Caps.m_Shadows && m_Options.m_Shadows && GetRenderPath() == RP_SHADER)
if (m_Caps.m_Shadows && g_RenderingOptions.GetShadows() && g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
{
m_CurrentCullGroup = CULL_SHADOWS;
@ -1862,7 +1690,7 @@ void CRenderer::RenderScene(Scene& scene)
if (waterScissor.GetVolume() > 0 && m_WaterManager->WillRenderFancyWater())
{
if (m_Options.m_WaterReflection)
if (g_RenderingOptions.GetWaterReflection())
{
m_CurrentCullGroup = CULL_REFLECTIONS;
@ -1872,7 +1700,7 @@ void CRenderer::RenderScene(Scene& scene)
scene.EnumerateObjects(reflectionCamera.GetFrustum(), this);
}
if (m_Options.m_WaterRefraction)
if (g_RenderingOptions.GetWaterRefraction())
{
m_CurrentCullGroup = CULL_REFRACTIONS;

73
source/renderer/Renderer.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2017 Wildfire Games.
/* Copyright (C) 2019 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -32,6 +32,7 @@
#include "graphics/ShaderDefines.h"
#include "renderer/Scene.h"
#include "renderer/RenderingOptions.h"
// necessary declarations
class CFontManager;
@ -72,25 +73,6 @@ class CRenderer :
public:
// various enumerations and renderer related constants
enum { NumAlphaMaps=14 };
enum Option {
OPT_NOVBO,
OPT_SHADOWS,
OPT_WATEREFFECTS,
OPT_WATERFANCYEFFECTS,
OPT_WATERREALDEPTH,
OPT_WATERREFLECTION,
OPT_WATERREFRACTION,
OPT_SHADOWSONWATER,
OPT_SHADOWPCF,
OPT_PARTICLES,
OPT_PREFERGLSL,
OPT_FOG,
OPT_SILHOUETTES,
OPT_SHOWSKY,
OPT_SMOOTHLOS,
OPT_POSTPROC,
OPT_DISPLAYFRUSTUM,
};
enum CullGroup {
CULL_DEFAULT,
@ -102,18 +84,6 @@ public:
CULL_MAX
};
enum RenderPath {
// If no rendering path is configured explicitly, the renderer
// will choose the path when Open() is called.
RP_DEFAULT,
// Classic fixed function.
RP_FIXED,
// Use new ARB/GLSL system
RP_SHADER
};
// stats class - per frame counts of number of draw calls, poly counts etc
struct Stats {
// set all stats to zero
@ -134,34 +104,6 @@ public:
size_t m_Particles;
};
// renderer options
struct Options {
bool m_NoVBO;
bool m_Shadows;
bool m_WaterEffects;
bool m_WaterFancyEffects;
bool m_WaterRealDepth;
bool m_WaterRefraction;
bool m_WaterReflection;
bool m_WaterShadows;
RenderPath m_RenderPath;
bool m_ShadowAlphaFix;
bool m_ARBProgramShadow;
bool m_ShadowPCF;
bool m_Particles;
bool m_PreferGLSL;
bool m_ForceAlphaTest;
bool m_GPUSkinning;
bool m_Fog;
bool m_Silhouettes;
bool m_SmoothLOS;
bool m_ShowSky;
bool m_Postproc;
bool m_DisplayFrustum;
} m_Options;
struct Caps {
bool m_VBO;
bool m_ARBProgram;
@ -183,14 +125,6 @@ public:
// resize renderer view
void Resize(int width,int height);
// set/get boolean renderer option
void SetOptionBool(enum Option opt, bool value);
bool GetOptionBool(enum Option opt) const;
void SetRenderPath(RenderPath rp);
RenderPath GetRenderPath() const { return m_Options.m_RenderPath; }
static CStr GetRenderPathName(RenderPath rp);
static RenderPath GetRenderPathByName(const CStr& name);
// return view width
int GetWidth() const { return m_Width; }
// return view height
@ -360,6 +294,7 @@ protected:
friend class ShaderInstancingModelRenderer;
friend class TerrainRenderer;
friend class WaterRenderer;
friend struct SRenderingOptions;
//BEGIN: Implementation of SceneCollector
void Submit(CPatch* patch);
@ -403,6 +338,8 @@ protected:
// enable oblique frustum clipping with the given clip plane
void SetObliqueFrustumClipping(CCamera& camera, const CVector4D& clipPlane) const;
void SetRenderPath(RenderPath rp);
void ReloadShaders();
void RecomputeSystemShaderDefines();

123
source/renderer/RenderingOptions.cpp Executable file
View File

@ -0,0 +1,123 @@
/* Copyright (C) 2019 Wildfire Games.
* 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/>.
*/
#include "precompiled.h"
#include "RenderingOptions.h"
#include "ps/ConfigDB.h"
#include "ps/CStr.h"
#include "renderer/Renderer.h"
SRenderingOptions g_RenderingOptions;
RenderPath RenderPathEnum::FromString(const CStr8& name)
{
if (name == "default")
return DEFAULT;
if (name == "fixed")
return FIXED;
if (name == "shader")
return SHADER;
LOGWARNING("Unknown render path %s", name.c_str());
return DEFAULT;
}
CStr8 RenderPathEnum::ToString(RenderPath path)
{
switch (path)
{
case RenderPath::DEFAULT:
return "default";
case RenderPath::FIXED:
return "fixed";
case RenderPath::SHADER:
return "shader";
}
return "default"; // Silence warning about reaching end of non-void function.
}
SRenderingOptions::SRenderingOptions()
{
m_NoVBO = false;
m_RenderPath = RenderPath::DEFAULT;
m_Shadows = false;
m_WaterEffects = false;
m_WaterFancyEffects = false;
m_WaterRealDepth = false;
m_WaterRefraction = false;
m_WaterReflection = false;
m_WaterShadows = false;
m_ShadowAlphaFix = true;
m_ARBProgramShadow = true;
m_ShadowPCF = false;
m_Particles = false;
m_Silhouettes = false;
m_PreferGLSL = false;
m_Fog = false;
m_ForceAlphaTest = false;
m_GPUSkinning = false;
m_SmoothLOS = false;
m_PostProc = false;
m_ShowSky = false;
m_DisplayFrustum = false;
m_RenderActors = true;
}
void SRenderingOptions::ReadConfig()
{
// TODO: be more consistent in use of the config system
CFG_GET_VAL("preferglsl", m_PreferGLSL);
CFG_GET_VAL("forcealphatest", m_ForceAlphaTest);
CFG_GET_VAL("gpuskinning", m_GPUSkinning);
CFG_GET_VAL("smoothlos", m_SmoothLOS);
CFG_GET_VAL("postproc", m_PostProc);
CFG_GET_VAL("renderactors", m_RenderActors);
}
void SRenderingOptions::SetShadows(bool value)
{
m_Shadows = value;
g_Renderer.MakeShadersDirty();
}
void SRenderingOptions::SetShadowPCF(bool value)
{
m_ShadowPCF = value;
g_Renderer.MakeShadersDirty();
}
void SRenderingOptions::SetFog(bool value)
{
m_Fog = value;
g_Renderer.MakeShadersDirty();
}
void SRenderingOptions::SetPreferGLSL(bool value)
{
m_PreferGLSL = value;
g_Renderer.MakeShadersDirty();
g_Renderer.RecomputeSystemShaderDefines();
}
void SRenderingOptions::SetRenderPath(RenderPath value)
{
m_RenderPath = value;
g_Renderer.SetRenderPath(m_RenderPath);
}

114
source/renderer/RenderingOptions.h Executable file
View File

@ -0,0 +1,114 @@
/* Copyright (C) 2019 Wildfire Games.
* 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/>.
*/
/**
* Keeps track of the settings used for rendering.
* Ideally this header file should remain very quick to parse,
* so avoid including other headers here unless absolutely necessary.
*/
#ifndef INCLUDED_RENDERINGOPTIONS
#define INCLUDED_RENDERINGOPTIONS
class CStr8;
class CRenderer;
enum RenderPath {
// If no rendering path is configured explicitly, the renderer
// will choose the path when Open() is called.
DEFAULT,
// Classic fixed function.
FIXED,
// Use new ARB/GLSL system
SHADER
};
struct RenderPathEnum
{
static RenderPath FromString(const CStr8& name);
static CStr8 ToString(RenderPath);
};
struct SRenderingOptions
{
// The renderer needs access to our private variables directly because capabilities have not yet been extracted
// and thus sometimes it needs to change the rendering options without the side-effects.
friend class CRenderer;
SRenderingOptions();
void ReadConfig();
#define OPTION_DEFAULT_SETTER(NAME, TYPE) \
public: void Set##NAME(TYPE value) { m_##NAME = value; }\
#define OPTION_CUSTOM_SETTER(NAME, TYPE) \
public: void Set##NAME(TYPE value);\
#define OPTION_GETTER(NAME, TYPE)\
public: TYPE Get##NAME() const { return m_##NAME; }\
#define OPTION_DEF(NAME, TYPE)\
private: TYPE m_##NAME;
#define OPTION(NAME, TYPE)\
OPTION_DEFAULT_SETTER(NAME, TYPE); OPTION_GETTER(NAME, TYPE); OPTION_DEF(NAME, TYPE);
#define OPTION_WITH_SIDE_EFFECT(NAME, TYPE)\
OPTION_CUSTOM_SETTER(NAME, TYPE); OPTION_GETTER(NAME, TYPE); OPTION_DEF(NAME, TYPE);
OPTION(NoVBO, bool);
OPTION_WITH_SIDE_EFFECT(Shadows, bool);
OPTION_WITH_SIDE_EFFECT(ShadowPCF, bool);
OPTION_WITH_SIDE_EFFECT(PreferGLSL, bool);
OPTION_WITH_SIDE_EFFECT(Fog, bool);
OPTION_WITH_SIDE_EFFECT(RenderPath, RenderPath);
OPTION(WaterEffects, bool);
OPTION(WaterFancyEffects, bool);
OPTION(WaterRealDepth, bool);
OPTION(WaterRefraction, bool);
OPTION(WaterReflection, bool);
OPTION(WaterShadows, bool);
OPTION(ShadowAlphaFix, bool);
OPTION(ARBProgramShadow, bool);
OPTION(Particles, bool);
OPTION(ForceAlphaTest, bool);
OPTION(GPUSkinning, bool);
OPTION(Silhouettes, bool);
OPTION(SmoothLOS, bool);
OPTION(ShowSky, bool);
OPTION(PostProc, bool);
OPTION(DisplayFrustum, bool);
OPTION(RenderActors, bool);
#undef OPTION_DEFAULT_SETTER
#undef OPTION_CUSTOM_SETTER
#undef OPTION_GETTER
#undef OPTION_DEF
#undef OPTION
#undef OPTION_WITH_SIDE_EFFECT
};
extern SRenderingOptions g_RenderingOptions;
#endif // INCLUDED_RENDERINGOPTIONS

7
source/renderer/ShadowMap.cpp
View File

@ -38,6 +38,7 @@
#include "ps/ConfigDB.h"
#include "ps/Profile.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
///////////////////////////////////////////////////////////////////////////////////////////////////
// ShadowMap implementation
@ -438,7 +439,7 @@ void ShadowMapInternals::CreateTexture()
Width, Height, formatname);
if (g_Renderer.m_Options.m_ShadowAlphaFix)
if (g_RenderingOptions.GetShadowAlphaFix())
{
glGenTextures(1, &DummyTexture);
g_Renderer.BindTexture(0, DummyTexture);
@ -497,7 +498,7 @@ void ShadowMapInternals::CreateTexture()
pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, Texture, 0);
if (g_Renderer.m_Options.m_ShadowAlphaFix)
if (g_RenderingOptions.GetShadowAlphaFix())
{
pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, DummyTexture, 0);
}
@ -525,7 +526,7 @@ void ShadowMapInternals::CreateTexture()
LOGWARNING("Framebuffer object incomplete: 0x%04X", status);
// Disable shadow rendering (but let the user try again if they want)
g_Renderer.m_Options.m_Shadows = false;
g_RenderingOptions.SetShadows(false);
}
}

6
source/renderer/SkyManager.cpp
View File

@ -39,7 +39,7 @@
#include "ps/World.h"
#include "renderer/SkyManager.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
SkyManager::SkyManager()
: m_RenderSky(true), m_SkyCubeMap(0)
@ -226,7 +226,7 @@ void SkyManager::RenderSky()
CShaderProgramPtr shader;
CShaderTechniquePtr skytech;
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
{
skytech = g_Renderer.GetShaderManager().LoadEffect(str_sky_simple);
skytech->BeginPass();
@ -280,7 +280,7 @@ void SkyManager::RenderSky()
glEnd();
if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER)
{
skytech->EndPass();
}

3
source/renderer/TerrainRenderer.cpp
View File

@ -46,6 +46,7 @@
#include "renderer/DecalRData.h"
#include "renderer/PatchRData.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
#include "renderer/ShadowMap.h"
#include "renderer/TerrainRenderer.h"
#include "renderer/VertexArray.h"
@ -649,7 +650,7 @@ bool TerrainRenderer::RenderFancyWater(const CShaderDefines& context, int cullGr
defines.Add(str_USE_SHADOWS_ON_WATER, str_1);
// haven't updated the ARB shader yet so I'll always load the GLSL
/*if (!g_Renderer.m_Options.m_PreferGLSL && !superFancy)
/*if (!g_RenderingOptions.GetPreferGLSL() && !superFancy)
m->fancyWaterShader = g_Renderer.GetShaderManager().LoadProgram("arb/water_high", defines);
else*/
m->fancyWaterShader = g_Renderer.GetShaderManager().LoadProgram("glsl/water_high", defines);

36
source/renderer/WaterManager.cpp
View File

@ -40,6 +40,7 @@
#include "renderer/WaterManager.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
#include "simulation2/Simulation2.h"
#include "simulation2/components/ICmpWaterManager.h"
@ -318,7 +319,8 @@ int WaterManager::LoadWaterTextures()
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
{
LOGWARNING("Reflection framebuffer object incomplete: 0x%04X", status);
g_Renderer.m_Options.m_WaterReflection = false;
g_RenderingOptions.SetWaterReflection(false);
UpdateQuality();
}
m_RefractionFbo = 0;
@ -333,7 +335,8 @@ int WaterManager::LoadWaterTextures()
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
{
LOGWARNING("Refraction framebuffer object incomplete: 0x%04X", status);
g_Renderer.m_Options.m_WaterRefraction = false;
g_RenderingOptions.SetWaterRefraction(false);
UpdateQuality();
}
pglGenFramebuffersEXT(1, &m_FancyEffectsFBO);
@ -348,7 +351,8 @@ int WaterManager::LoadWaterTextures()
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
{
LOGWARNING("Fancy Effects framebuffer object incomplete: 0x%04X", status);
g_Renderer.m_Options.m_WaterRefraction = false;
g_RenderingOptions.SetWaterRefraction(false);
UpdateQuality();
}
pglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, currentFbo);
@ -1125,34 +1129,34 @@ void WaterManager::SetMapSize(size_t size)
// This will set the bools properly
void WaterManager::UpdateQuality()
{
if (g_Renderer.GetOptionBool(CRenderer::OPT_WATEREFFECTS) != m_WaterEffects)
if (g_RenderingOptions.GetWaterEffects() != m_WaterEffects)
{
m_WaterEffects = g_Renderer.GetOptionBool(CRenderer::OPT_WATEREFFECTS);
m_WaterEffects = g_RenderingOptions.GetWaterEffects();
m_NeedsReloading = true;
}
if (g_Renderer.GetOptionBool(CRenderer::OPT_WATERFANCYEFFECTS) != m_WaterFancyEffects) {
m_WaterFancyEffects = g_Renderer.GetOptionBool(CRenderer::OPT_WATERFANCYEFFECTS);
if (g_RenderingOptions.GetWaterFancyEffects() != m_WaterFancyEffects) {
m_WaterFancyEffects = g_RenderingOptions.GetWaterFancyEffects();
m_NeedsReloading = true;
}
if (g_Renderer.GetOptionBool(CRenderer::OPT_WATERREALDEPTH) != m_WaterRealDepth) {
m_WaterRealDepth = g_Renderer.GetOptionBool(CRenderer::OPT_WATERREALDEPTH);
if (g_RenderingOptions.GetWaterRealDepth() != m_WaterRealDepth) {
m_WaterRealDepth = g_RenderingOptions.GetWaterRealDepth();
m_NeedsReloading = true;
}
if (g_Renderer.GetOptionBool(CRenderer::OPT_WATERREFRACTION) != m_WaterRefraction) {
m_WaterRefraction = g_Renderer.GetOptionBool(CRenderer::OPT_WATERREFRACTION);
if (g_RenderingOptions.GetWaterRefraction() != m_WaterRefraction) {
m_WaterRefraction = g_RenderingOptions.GetWaterRefraction();
m_NeedsReloading = true;
}
if (g_Renderer.GetOptionBool(CRenderer::OPT_WATERREFLECTION) != m_WaterReflection) {
m_WaterReflection = g_Renderer.GetOptionBool(CRenderer::OPT_WATERREFLECTION);
if (g_RenderingOptions.GetWaterReflection() != m_WaterReflection) {
m_WaterReflection = g_RenderingOptions.GetWaterReflection();
m_NeedsReloading = true;
}
if (g_Renderer.GetOptionBool(CRenderer::OPT_SHADOWSONWATER) != m_WaterShadows) {
m_WaterShadows = g_Renderer.GetOptionBool(CRenderer::OPT_SHADOWSONWATER);
if (g_RenderingOptions.GetWaterShadows() != m_WaterShadows) {
m_WaterShadows = g_RenderingOptions.GetWaterShadows();
m_NeedsReloading = true;
}
}
bool WaterManager::WillRenderFancyWater()
{
return m_RenderWater && m_WaterEffects && g_Renderer.GetCapabilities().m_PrettyWater;
return m_RenderWater && g_RenderingOptions.GetWaterEffects() && g_Renderer.GetCapabilities().m_PrettyWater;
}

52
source/renderer/scripting/JSInterface_Renderer.cpp
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2018 Wildfire Games.
/* Copyright (C) 2019 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -20,49 +20,49 @@
#include "JSInterface_Renderer.h"
#include "graphics/TextureManager.h"
#include "ps/Profile.h"
#include "renderer/RenderingOptions.h"
#include "renderer/Renderer.h"
#include "renderer/ShadowMap.h"
#include "scriptinterface/ScriptInterface.h"
#define IMPLEMENT_BOOLEAN_SCRIPT_SETTING(NAME, SCRIPTNAME) \
bool JSI_Renderer::Get##SCRIPTNAME##Enabled(ScriptInterface::CxPrivate* UNUSED(pCxPrivate)) \
#define IMPLEMENT_BOOLEAN_SCRIPT_SETTING(NAME) \
bool JSI_Renderer::Get##NAME##Enabled(ScriptInterface::CxPrivate* UNUSED(pCxPrivate)) \
{ \
return g_Renderer.GetOptionBool(CRenderer::OPT_##NAME); \
return g_RenderingOptions.Get##NAME(); \
} \
\
void JSI_Renderer::Set##SCRIPTNAME##Enabled(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), bool Enabled) \
void JSI_Renderer::Set##NAME##Enabled(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), bool enabled) \
{ \
g_Renderer.SetOptionBool(CRenderer::OPT_##NAME, Enabled); \
g_RenderingOptions.Set##NAME(enabled); \
}
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(PARTICLES, Particles);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(PREFERGLSL, PreferGLSL);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WATEREFFECTS, WaterEffects);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WATERFANCYEFFECTS, WaterFancyEffects);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(SHADOWPCF, ShadowPCF);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(SHADOWS, Shadows);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WATERREALDEPTH, WaterRealDepth);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WATERREFLECTION, WaterReflection);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WATERREFRACTION, WaterRefraction);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(SHADOWSONWATER, WaterShadows);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(FOG, Fog);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(SILHOUETTES, Silhouettes);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(SHOWSKY, ShowSky);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(SMOOTHLOS, SmoothLOS);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(POSTPROC, Postproc);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(DISPLAYFRUSTUM, DisplayFrustum);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(Shadows);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(ShadowPCF);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(Particles);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(PreferGLSL);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WaterEffects);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WaterFancyEffects);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WaterRealDepth);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WaterReflection);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WaterRefraction);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(WaterShadows);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(Fog);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(Silhouettes);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(ShowSky);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(SmoothLOS);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(PostProc);
IMPLEMENT_BOOLEAN_SCRIPT_SETTING(DisplayFrustum);
#undef IMPLEMENT_BOOLEAN_SCRIPT_SETTING
std::string JSI_Renderer::GetRenderPath(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
{
return CRenderer::GetRenderPathName(g_Renderer.GetRenderPath());
return RenderPathEnum::ToString(g_RenderingOptions.GetRenderPath());
}
void JSI_Renderer::SetRenderPath(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& name)
{
g_Renderer.SetRenderPath(CRenderer::GetRenderPathByName(name));
g_RenderingOptions.SetRenderPath(RenderPathEnum::FromString(name));
}
void JSI_Renderer::RecreateShadowMap(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
@ -99,7 +99,7 @@ void JSI_Renderer::RegisterScriptFunctions(const ScriptInterface& scriptInterfac
REGISTER_BOOLEAN_SCRIPT_SETTING(Silhouettes);
REGISTER_BOOLEAN_SCRIPT_SETTING(ShowSky);
REGISTER_BOOLEAN_SCRIPT_SETTING(SmoothLOS);
REGISTER_BOOLEAN_SCRIPT_SETTING(Postproc);
REGISTER_BOOLEAN_SCRIPT_SETTING(PostProc);
REGISTER_BOOLEAN_SCRIPT_SETTING(DisplayFrustum);
}

4
source/renderer/scripting/JSInterface_Renderer.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2018 Wildfire Games.
/* Copyright (C) 2019 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -45,7 +45,7 @@ namespace JSI_Renderer
DECLARE_BOOLEAN_SCRIPT_SETTING(Silhouettes);
DECLARE_BOOLEAN_SCRIPT_SETTING(ShowSky);
DECLARE_BOOLEAN_SCRIPT_SETTING(SmoothLOS);
DECLARE_BOOLEAN_SCRIPT_SETTING(Postproc);
DECLARE_BOOLEAN_SCRIPT_SETTING(PostProc);
DECLARE_BOOLEAN_SCRIPT_SETTING(DisplayFrustum);
void RegisterScriptFunctions(const ScriptInterface& scriptInterface);

3
source/simulation2/components/CCmpUnitRenderer.cpp
View File

@ -37,6 +37,7 @@
#include "maths/Matrix3D.h"
#include "ps/GameSetup/Config.h"
#include "ps/Profile.h"
#include "renderer/RenderingOptions.h"
#include "renderer/Scene.h"
#include "tools/atlas/GameInterface/GameLoop.h"
@ -406,7 +407,7 @@ void CCmpUnitRenderer::RenderSubmit(SceneCollector& collector, const CFrustum& f
if (unit.visibility == ICmpRangeManager::VIS_HIDDEN)
continue;
if (!g_AtlasGameLoop->running && !g_RenderActors && (unit.flags & ACTOR_ONLY))
if (!g_AtlasGameLoop->running && !g_RenderingOptions.GetRenderActors() && (unit.flags & ACTOR_ONLY))
continue;
if (!g_AtlasGameLoop->running && (unit.flags & VISIBLE_IN_ATLAS_ONLY))

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

@ -42,6 +42,7 @@
#include "ps/GameSetup/Config.h"
#include "ps/ProfileViewer.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
#include "renderer/Scene.h"
#include "renderer/SkyManager.h"
#include "renderer/WaterManager.h"
@ -253,7 +254,7 @@ ActorViewer::ActorViewer()
m.WalkEnabled = false;
m.GroundEnabled = true;
m.WaterEnabled = false;
m.ShadowsEnabled = g_Renderer.GetOptionBool(CRenderer::OPT_SHADOWS);
m.ShadowsEnabled = g_RenderingOptions.GetShadows();
m.SelectionBoxEnabled = false;
m.AxesMarkerEnabled = false;
m.PropPointsMode = 0;
@ -447,8 +448,8 @@ void ActorViewer::SetEnabled(bool enabled)
if (enabled)
{
// Set shadows, sky and water.
m.OldShadows = g_Renderer.GetOptionBool(CRenderer::OPT_SHADOWS);
g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWS, m.ShadowsEnabled);
m.OldShadows = g_RenderingOptions.GetShadows();
g_RenderingOptions.SetShadows(m.ShadowsEnabled);
m.OldSky = g_Renderer.GetSkyManager()->GetRenderSky();
g_Renderer.GetSkyManager()->SetRenderSky(false);
@ -459,7 +460,7 @@ void ActorViewer::SetEnabled(bool enabled)
else
{
// Restore the old renderer state
g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWS, m.OldShadows);
g_RenderingOptions.SetShadows(m.OldShadows);
g_Renderer.GetSkyManager()->SetRenderSky(m.OldSky);
g_Renderer.GetWaterManager()->m_RenderWater = m.OldWater;
}

2
source/tools/atlas/GameInterface/View.cpp
View File

@ -352,7 +352,7 @@ void AtlasViewGame::SetParam(const std::wstring& name, const std::wstring& value
}
else if (name == L"renderpath")
{
g_Renderer.SetRenderPath(g_Renderer.GetRenderPathByName(CStrW(value).ToUTF8()));
g_RenderingOptions.SetRenderPath(RenderPathEnum::FromString(CStrW(value).ToUTF8()));
}
}