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

Replaces unclear PreferGLSL by direct renderer backend choice.

Browse Source 
Commented By: Stan
Differential Revision: https://code.wildfiregames.com/D4363
This was SVN commit r26069.
This commit is contained in:
Vladislav Belov 2021-12-14 06:34:02 +00:00
parent f28efbaa87
commit 3809457513
26 changed files with 102 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
binaries/data/config/default.cfg
View File

@ -109,19 +109,16 @@ gl.checkerrorafterswap = false
; The "system" one doesn't support a visual change of the cursor.
cursorbackend = "sdl"
; Specify the render path. This can be one of:
; default Automatically select one of the below, depending on system capabilities
; fixed Only use OpenGL fixed function pipeline
; shader Use vertex/fragment shaders for transform and lighting where possible
; Using 'fixed' instead of 'default' may work around some graphics-related problems,
; but will reduce performance and features when a modern graphics card is available.
; Backends for all graphics rendering:
; glarb - GL with legacy assembler-like shaders, might used only for buggy drivers.
; gl - GL with GLSL shaders, should be used by default.
rendererbackend = "gl"
; Should not be edited. It's used only for preventing of running fixed pipeline.
renderpath = default
;;;;; EXPERIMENTAL ;;;;;
; Prefer GLSL shaders over ARB shaders. Allows fancier graphical effects.
preferglsl = false
; Experimental probably-non-working GPU skinning support; requires preferglsl; use at own risk
; Experimental probably-non-working GPU skinning support; requires GLSL; use at own risk
gpuskinning = false
; Use smooth LOS interpolation

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

@ -177,16 +177,20 @@
"options":
[
{
"type": "boolean",
"label": "Prefer GLSL",
"tooltip": "Use OpenGL 2.0 shaders (recommended).",
"config": "preferglsl"
"type": "dropdown",
"label": "Renderer backend",
"tooltip": "Choose the renderer's backend. REQUIRES GAME RESTART",
"config": "rendererbackend",
"list": [
{ "value": "gl", "label": "OpenGL", "tooltip": "Default OpenGL backend with GLSL. REQUIRES GAME RESTART" },
{ "value": "glarb", "label": "OpenGL ARB", "tooltip": "Legacy OpenGL backend with ARB shaders. REQUIRES GAME RESTART" }
]
},
{
"type": "boolean",
"label": "Fog",
"tooltip": "Enable fog.",
"dependencies": ["preferglsl"],
"dependencies": [{ "config": "rendererbackend", "op": "!=", "value": "glarb" }],
"config": "fog"
},
{
@ -199,7 +203,7 @@
"type": "dropdown",
"label": "Antialiasing",
"tooltip": "Reduce aliasing effect on edges.",
"dependencies": ["postproc", "preferglsl"],
"dependencies": ["postproc", { "config": "rendererbackend", "op": "!=", "value": "glarb" }],
"config": "antialiasing",
"list": [
{ "value": "disabled", "label": "Disabled", "tooltip": "Do not use antialiasing." },
@ -214,7 +218,7 @@
"type": "dropdown",
"label": "Sharpening",
"tooltip": "Reduce blurry effects.",
"dependencies": ["postproc", "preferglsl"],
"dependencies": ["postproc", { "config": "rendererbackend", "op": "!=", "value": "glarb" }],
"config": "sharpening",
"list": [
{ "value": "disabled", "label": "Disabled", "tooltip": "Do not use sharpening." },
@ -225,7 +229,11 @@
"type": "slider",
"label": "Sharpness factor",
"tooltip": "The sharpness of the choosen pass.",
"dependencies": ["postproc", "preferglsl", { "config": "sharpening", "op": "!=", "value": "disabled" }],
"dependencies": [
"postproc",
{ "config": "rendererbackend", "op": "!=", "value": "glarb" },
{ "config": "sharpening", "op": "!=", "value": "disabled" }
],
"config": "sharpness",
"min": 0,
"max": 1

3
source/graphics/Canvas2D.cpp
View File

@ -76,8 +76,7 @@ public:
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
CShaderDefines defines;
Tech = g_Renderer.GetShaderManager().LoadEffect(
str_canvas2d, g_Renderer.GetSystemShaderDefines(), defines);
Tech = g_Renderer.GetShaderManager().LoadEffect(str_canvas2d, defines);
ENSURE(Tech);
Tech->BeginPass();
}

4
source/graphics/MiniMapTexture.cpp
View File

@ -364,7 +364,7 @@ void CMiniMapTexture::RenderFinalTexture()
CShaderDefines baseDefines;
baseDefines.Add(str_MINIMAP_BASE, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), baseDefines);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, baseDefines);
tech->BeginPass();
shader = tech->GetShader();
@ -415,7 +415,7 @@ void CMiniMapTexture::RenderFinalTexture()
CShaderDefines pointDefines;
pointDefines.Add(str_MINIMAP_POINT, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), pointDefines);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, pointDefines);
tech->BeginPass();
shader = tech->GetShader();
shader->Uniform(str_transform, baseTransform);

28
source/graphics/ShaderManager.cpp
View File

@ -31,6 +31,7 @@
#include "ps/Profile.h"
#include "ps/XML/Xeromyces.h"
#include "ps/XML/XMLWriter.h"
#include "ps/VideoMode.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
@ -158,7 +159,7 @@ bool CShaderManager::NewProgram(const char* name, const CShaderDefines& baseDefi
XMBElement Root = XeroFile.GetRoot();
const bool isGLSL = (Root.GetAttributes().GetNamedItem(at_type) == "glsl");
if (!isGLSL && g_RenderingOptions.GetPreferGLSL())
if (!isGLSL && g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB)
LOGWARNING("CShaderManager::NewProgram: '%s': trying to load a non-GLSL program with enabled GLSL", name);
VfsPath vertexFile;
@ -335,35 +336,29 @@ size_t CShaderManager::EffectCacheKeyHash::operator()(const EffectCacheKey& key)
{
size_t hash = 0;
hash_combine(hash, key.name.GetHash());
hash_combine(hash, key.defines1.GetHash());
hash_combine(hash, key.defines2.GetHash());
hash_combine(hash, key.defines.GetHash());
return hash;
}
bool CShaderManager::EffectCacheKey::operator==(const EffectCacheKey& b) const
{
return (name == b.name && defines1 == b.defines1 && defines2 == b.defines2);
return name == b.name && defines == b.defines;
}
CShaderTechniquePtr CShaderManager::LoadEffect(CStrIntern name)
{
return LoadEffect(name, g_Renderer.GetSystemShaderDefines(), CShaderDefines());
return LoadEffect(name, CShaderDefines());
}
CShaderTechniquePtr CShaderManager::LoadEffect(CStrIntern name, const CShaderDefines& defines1, const CShaderDefines& defines2)
CShaderTechniquePtr CShaderManager::LoadEffect(CStrIntern name, const CShaderDefines& defines)
{
// Return the cached effect, if there is one
EffectCacheKey key = { name, defines1, defines2 };
EffectCacheKey key = { name, defines };
EffectCacheMap::iterator it = m_EffectCache.find(key);
if (it != m_EffectCache.end())
return it->second;
// First time we've seen this key, so construct a new effect:
// Merge the two sets of defines, so NewEffect doesn't have to care about the split
CShaderDefines defines(defines1);
defines.SetMany(defines2);
CShaderTechniquePtr tech(new CShaderTechnique());
if (!NewEffect(name.c_str(), defines, tech))
{
@ -411,9 +406,10 @@ bool CShaderManager::NewEffect(const char* name, const CShaderDefines& baseDefin
#undef EL
// Read some defines that influence how we pick techniques
bool hasARB = (baseDefines.GetInt("SYS_HAS_ARB") != 0);
bool hasGLSL = (baseDefines.GetInt("SYS_HAS_GLSL") != 0);
bool preferGLSL = (baseDefines.GetInt("SYS_PREFER_GLSL") != 0);
const CRenderer::Caps& capabilities = g_Renderer.GetCapabilities();
const bool hasARB = capabilities.m_ARBProgram;
const bool hasGLSL = capabilities.m_FragmentShader && capabilities.m_VertexShader;
const bool preferGLSL = g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB;
// Prepare the preprocessor for conditional tests
CPreprocessorWrapper preprocessor;
@ -423,7 +419,7 @@ bool CShaderManager::NewEffect(const char* name, const CShaderDefines& baseDefin
// Find all the techniques that we can use, and their preference
std::vector<std::pair<XMBElement, int> > usableTechs;
std::vector<std::pair<XMBElement, int>> usableTechs;
XERO_ITER_EL(Root, Technique)
{

7
source/graphics/ShaderManager.h
View File

@ -42,10 +42,10 @@ public:
* Load a shader effect.
* Effects can be implemented via many techniques; this returns the best usable technique.
* @param name name of effect XML specification (file is loaded from shaders/effects/${name}.xml)
* @param defines1,defines2 key/value set of preprocessor definitions; defines2 has higher precedence
* @param defines key/value set of preprocessor definitions
* @return loaded technique, or empty technique on error
*/
CShaderTechniquePtr LoadEffect(CStrIntern name, const CShaderDefines& defines1, const CShaderDefines& defines2);
CShaderTechniquePtr LoadEffect(CStrIntern name, const CShaderDefines& defines);
/**
* Load a shader effect, with default system defines (from CRenderer::GetSystemShaderDefines).
@ -87,8 +87,7 @@ private:
struct EffectCacheKey
{
CStrIntern name;
CShaderDefines defines1;
CShaderDefines defines2;
CShaderDefines defines;
bool operator==(const EffectCacheKey& b) const;
};

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

@ -409,7 +409,7 @@ void CMiniMap::Draw(CCanvas2D& canvas)
CShaderDefines baseDefines;
baseDefines.Add(str_MINIMAP_BASE, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), baseDefines);
tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, baseDefines);
tech->BeginPass();
shader = tech->GetShader();

3
source/ps/CStrInternStatic.h
View File

@ -62,9 +62,6 @@ X(RENDER_DEBUG_MODE_ALPHA)
X(RENDER_DEBUG_MODE_CUSTOM)
X(RENDER_DEBUG_MODE_NONE)
X(SHADOWS_CASCADE_COUNT)
X(SYS_HAS_ARB)
X(SYS_HAS_GLSL)
X(SYS_PREFER_GLSL)
X(USE_FANCY_EFFECTS)
X(USE_FP_SHADOW)
X(USE_GPU_SKINNING)

7
source/ps/VideoMode.cpp
View File

@ -231,6 +231,13 @@ void CVideoMode::ReadConfig()
CFG_GET_VAL("display", m_ConfigDisplay);
CFG_GET_VAL("hidpi", m_ConfigEnableHiDPI);
CFG_GET_VAL("vsync", m_ConfigVSync);
CStr rendererBackend;
CFG_GET_VAL("rendererbackend", rendererBackend);
if (rendererBackend == "glarb")
m_Backend = Backend::GL_ARB;
else
m_Backend = Backend::GL;
}
bool CVideoMode::SetVideoMode(int w, int h, int bpp, bool fullscreen)

10
source/ps/VideoMode.h
View File

@ -28,6 +28,12 @@ typedef void* SDL_GLContext;
class CVideoMode
{
public:
enum class Backend
{
GL,
GL_ARB
};
CVideoMode();
~CVideoMode();
@ -104,6 +110,8 @@ public:
void SetCursor(const CStrW& name);
void ResetCursor();
Backend GetBackend() const { return m_Backend; }
private:
void ReadConfig();
int GetBestBPP();
@ -157,6 +165,8 @@ private:
class CCursor;
std::unique_ptr<CCursor> m_Cursor;
Backend m_Backend = Backend::GL;
};
extern CVideoMode g_VideoMode;

4
source/renderer/DecalRData.cpp
View File

@ -114,8 +114,10 @@ void CDecalRData::RenderDecals(
continue;
}
CShaderDefines defines = contextDecal;
defines.SetMany(material.GetShaderDefines(0));
CShaderTechniquePtr techBase = g_Renderer.GetShaderManager().LoadEffect(
material.GetShaderEffect(), contextDecal, material.GetShaderDefines(0));
material.GetShaderEffect(), defines);
if (!techBase)
{
LOGERROR("Terrain renderer failed to load shader effect (%s)\n",

4
source/renderer/ModelRenderer.cpp
View File

@ -489,7 +489,9 @@ void ShaderModelRenderer::Render(const RenderModifierPtr& modifier, const CShade
PROFILE3("processing material buckets");
for (MaterialBuckets_t::iterator it = materialBuckets.begin(); it != materialBuckets.end(); ++it)
{
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(it->first.effect, context, it->first.defines);
CShaderDefines defines = context;
defines.SetMany(it->first.defines);
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(it->first.effect, defines);
// Skip invalid techniques (e.g. from data file errors)
if (!tech)

3
source/renderer/OverlayRenderer.cpp
View File

@ -49,8 +49,7 @@ namespace
CShaderTechniquePtr GetOverlayLineShaderTechnique(const CShaderDefines& defines)
{
return g_Renderer.GetShaderManager().LoadEffect(
str_overlay_line, g_Renderer.GetSystemShaderDefines(), defines);
return g_Renderer.GetShaderManager().LoadEffect(str_overlay_line, defines);
}
} // anonymous namespace

4
source/renderer/ParticleRenderer.cpp
View File

@ -88,8 +88,8 @@ void ParticleRenderer::PrepareForRendering(const CShaderDefines& context)
// renderer initialisation is complete, so load it the first time through here
if (!m->shader)
{
m->shader = g_Renderer.GetShaderManager().LoadEffect(str_particle, context, CShaderDefines());
m->shaderSolid = g_Renderer.GetShaderManager().LoadEffect(str_particle_solid, context, CShaderDefines());
m->shader = g_Renderer.GetShaderManager().LoadEffect(str_particle, context);
m->shaderSolid = g_Renderer.GetShaderManager().LoadEffect(str_particle_solid, context);
}
++m->frameNumber;

11
source/renderer/PatchRData.cpp
View File

@ -36,6 +36,7 @@
#include "ps/GameSetup/Config.h"
#include "ps/Profile.h"
#include "ps/Pyrogenesis.h"
#include "ps/VideoMode.h"
#include "ps/World.h"
#include "renderer/AlphaMapCalculator.h"
#include "renderer/DebugRenderer.h"
@ -717,8 +718,10 @@ void CPatchRData::RenderBases(
LOGERROR("Terrain renderer failed to load shader effect.\n");
continue;
}
CShaderDefines defines = context;
defines.SetMany(material.GetShaderDefines(0));
CShaderTechniquePtr techBase = g_Renderer.GetShaderManager().LoadEffect(
material.GetShaderEffect(), context, material.GetShaderDefines(0));
material.GetShaderEffect(), defines);
BatchElements& batch = PooledPairGet(
PooledMapGet(
@ -926,8 +929,10 @@ void CPatchRData::RenderBlends(
layer.m_Texture = bestTex;
if (!bestTex->GetMaterial().GetSamplers().empty())
{
CShaderDefines defines = contextBlend;
defines.SetMany(bestTex->GetMaterial().GetShaderDefines(0));
layer.m_ShaderTech = g_Renderer.GetShaderManager().LoadEffect(
bestTex->GetMaterial().GetShaderEffect(), contextBlend, bestTex->GetMaterial().GetShaderDefines(0));
bestTex->GetMaterial().GetShaderEffect(), defines);
}
batches.push_back(layer);
}
@ -1410,7 +1415,7 @@ void CPatchRData::RenderWater(CShaderProgramPtr& shader, bool onlyShore, bool fi
g_Renderer.m_Stats.m_WaterTris += m_VBWaterIndices->m_Count / 3;
}
if (m_VBWaterShore && g_RenderingOptions.GetPreferGLSL() &&
if (m_VBWaterShore && g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB &&
g_Renderer.GetWaterManager()->m_WaterEffects &&
g_Renderer.GetWaterManager()->m_WaterFancyEffects)
{

22
source/renderer/PostprocManager.cpp
View File

@ -30,6 +30,7 @@
#include "ps/CStrInternStatic.h"
#include "ps/Filesystem.h"
#include "ps/Game.h"
#include "ps/VideoMode.h"
#include "ps/World.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
@ -227,8 +228,7 @@ void CPostprocManager::ApplyBlurDownscale2x(GLuint inTex, GLuint outTex, int inW
// Get bloom shader with instructions to simply copy texels.
CShaderDefines defines;
defines.Add(str_BLOOM_NOP, str_1);
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom,
g_Renderer.GetSystemShaderDefines(), defines);
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom, defines);
tech->BeginPass();
CShaderProgramPtr shader = tech->GetShader();
@ -286,8 +286,7 @@ void CPostprocManager::ApplyBlurGauss(GLuint inOutTex, GLuint tempTex, int inWid
// Get bloom shader, for a horizontal Gaussian blur pass.
CShaderDefines defines2;
defines2.Add(str_BLOOM_PASS_H, str_1);
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom,
g_Renderer.GetSystemShaderDefines(), defines2);
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom, defines2);
tech->BeginPass();
CShaderProgramPtr shader = tech->GetShader();
@ -332,8 +331,7 @@ void CPostprocManager::ApplyBlurGauss(GLuint inOutTex, GLuint tempTex, int inWid
// Get bloom shader, for a vertical Gaussian blur pass.
CShaderDefines defines3;
defines3.Add(str_BLOOM_PASS_V, str_1);
tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom,
g_Renderer.GetSystemShaderDefines(), defines3);
tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom, defines3);
tech->BeginPass();
shader = tech->GetShader();
@ -500,8 +498,9 @@ void CPostprocManager::ApplyPostproc()
// Don't do anything if we are using the default effect and no AA.
const bool hasEffects = m_PostProcEffect != L"default";
const bool hasAA = m_AATech && g_RenderingOptions.GetPreferGLSL();
const bool hasSharp = m_SharpTech && g_RenderingOptions.GetPreferGLSL();
const bool hasARB = g_VideoMode.GetBackend() == CVideoMode::Backend::GL_ARB;
const bool hasAA = m_AATech && !hasARB;
const bool hasSharp = m_SharpTech && !hasARB;
if (!hasEffects && !hasAA && !hasSharp)
return;
@ -590,7 +589,7 @@ void CPostprocManager::SetPostEffect(const CStrW& name)
void CPostprocManager::UpdateAntiAliasingTechnique()
{
if (!g_RenderingOptions.GetPreferGLSL() || !m_IsInitialized)
if (g_VideoMode.GetBackend() == CVideoMode::Backend::GL_ARB || !m_IsInitialized)
return;
CStr newAAName;
@ -624,8 +623,7 @@ void CPostprocManager::UpdateAntiAliasingTechnique()
ogl_HaveVersion("3.3") &&
ogl_HaveExtension("GL_ARB_multisample") &&
ogl_HaveExtension("GL_ARB_texture_multisample") &&
!m_AllowedSampleCounts.empty() &&
g_RenderingOptions.GetPreferGLSL();
!m_AllowedSampleCounts.empty();
if (!is_msaa_supported)
{
LOGWARNING("MSAA is unsupported.");
@ -650,7 +648,7 @@ void CPostprocManager::UpdateAntiAliasingTechnique()
void CPostprocManager::UpdateSharpeningTechnique()
{
if (!g_RenderingOptions.GetPreferGLSL() || !m_IsInitialized)
if (g_VideoMode.GetBackend() == CVideoMode::Backend::GL_ARB || !m_IsInitialized)
return;
CStr newSharpName;

32
source/renderer/Renderer.cpp
View File

@ -54,6 +54,7 @@
#include "graphics/Terrain.h"
#include "graphics/Texture.h"
#include "graphics/TextureManager.h"
#include "ps/VideoMode.h"
#include "renderer/DebugRenderer.h"
#include "renderer/HWLightingModelRenderer.h"
#include "renderer/InstancingModelRenderer.h"
@ -477,27 +478,11 @@ void CRenderer::EnumCaps()
#endif
}
void CRenderer::RecomputeSystemShaderDefines()
{
CShaderDefines defines;
if (m_Caps.m_ARBProgram)
defines.Add(str_SYS_HAS_ARB, str_1);
if (m_Caps.m_VertexShader && m_Caps.m_FragmentShader)
defines.Add(str_SYS_HAS_GLSL, str_1);
if (g_RenderingOptions.GetPreferGLSL())
defines.Add(str_SYS_PREFER_GLSL, str_1);
m_SystemShaderDefines = defines;
}
void CRenderer::ReloadShaders()
{
ENSURE(m->IsOpen);
m->globalContext = m_SystemShaderDefines;
m->globalContext = CShaderDefines();
if (m_Caps.m_Shadows && g_RenderingOptions.GetShadows())
{
@ -518,18 +503,18 @@ void CRenderer::ReloadShaders()
m->globalContext.Add(str_RENDER_DEBUG_MODE,
RenderDebugModeEnum::ToString(g_RenderingOptions.GetRenderDebugMode()));
if (g_RenderingOptions.GetPreferGLSL() && g_RenderingOptions.GetFog())
if (g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB && g_RenderingOptions.GetFog())
m->globalContext.Add(str_USE_FOG, str_1);
m->Model.ModShader = LitRenderModifierPtr(new ShaderRenderModifier());
ENSURE(g_RenderingOptions.GetRenderPath() != RenderPath::FIXED);
m->Model.VertexRendererShader = ModelVertexRendererPtr(new ShaderModelVertexRenderer());
m->Model.VertexInstancingShader = ModelVertexRendererPtr(new InstancingModelRenderer(false, g_RenderingOptions.GetPreferGLSL()));
m->Model.VertexInstancingShader = ModelVertexRendererPtr(new InstancingModelRenderer(false, g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB));
if (g_RenderingOptions.GetGPUSkinning()) // TODO: should check caps and GLSL etc too
{
m->Model.VertexGPUSkinningShader = ModelVertexRendererPtr(new InstancingModelRenderer(true, g_RenderingOptions.GetPreferGLSL()));
m->Model.VertexGPUSkinningShader = ModelVertexRendererPtr(new InstancingModelRenderer(true, g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB));
m->Model.NormalSkinned = ModelRendererPtr(new ShaderModelRenderer(m->Model.VertexGPUSkinningShader));
m->Model.TranspSkinned = ModelRendererPtr(new ShaderModelRenderer(m->Model.VertexGPUSkinningShader));
}
@ -580,8 +565,6 @@ bool CRenderer::Open(int width, int height)
// Validate the currently selected render path
SetRenderPath(g_RenderingOptions.GetRenderPath());
RecomputeSystemShaderDefines();
// Let component renderers perform one-time initialization after graphics capabilities and
// the shader path have been determined.
m->overlayRenderer.Initialize();
@ -621,7 +604,7 @@ void CRenderer::SetRenderPath(RenderPath rp)
// Renderer has been opened, so validate the selected renderpath
if (rp == RenderPath::DEFAULT)
{
if (m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && g_RenderingOptions.GetPreferGLSL()))
if (m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB))
rp = RenderPath::SHADER;
else
rp = RenderPath::FIXED;
@ -629,7 +612,7 @@ void CRenderer::SetRenderPath(RenderPath rp)
if (rp == RenderPath::SHADER)
{
if (!(m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && g_RenderingOptions.GetPreferGLSL())))
if (!(m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB)))
{
LOGWARNING("Falling back to fixed function\n");
rp = RenderPath::FIXED;
@ -640,7 +623,6 @@ void CRenderer::SetRenderPath(RenderPath rp)
g_RenderingOptions.m_RenderPath = rp;
MakeShadersDirty();
RecomputeSystemShaderDefines();
// We might need to regenerate some render data after changing path
if (g_Game)

5
source/renderer/Renderer.h
View File

@ -264,8 +264,6 @@ public:
CFontManager& GetFontManager();
CShaderDefines GetSystemShaderDefines() { return m_SystemShaderDefines; }
CTimeManager& GetTimeManager();
CPostprocManager& GetPostprocManager();
@ -355,7 +353,6 @@ protected:
void SetRenderPath(RenderPath rp);
void ReloadShaders();
void RecomputeSystemShaderDefines();
// RENDERER DATA:
/// Private data that is not needed by inline functions
@ -374,8 +371,6 @@ protected:
// Current overlay rendering mode.
ERenderMode m_OverlayRenderMode;
CShaderDefines m_SystemShaderDefines;
SViewPort m_Viewport;
/**

31
source/renderer/RenderingOptions.cpp
View File

@ -23,6 +23,7 @@
#include "ps/ConfigDB.h"
#include "ps/CStr.h"
#include "ps/CStrInternStatic.h"
#include "ps/VideoMode.h"
#include "renderer/Renderer.h"
#include "renderer/PostprocManager.h"
#include "renderer/ShadowMap.h"
@ -120,7 +121,6 @@ CRenderingOptions::CRenderingOptions() : m_ConfigHooks(new ConfigHooks())
m_ShadowPCF = false;
m_Particles = false;
m_Silhouettes = false;
m_PreferGLSL = false;
m_Fog = false;
m_ForceAlphaTest = false;
m_GPUSkinning = false;
@ -144,14 +144,6 @@ void CRenderingOptions::ReadConfigAndSetupHooks()
SetRenderPath(RenderPathEnum::FromString(renderPath));
});
m_ConfigHooks->Setup("preferglsl", [this]() {
bool enabled;
CFG_GET_VAL("preferglsl", enabled);
SetPreferGLSL(enabled);
if (CRenderer::IsInitialised())
g_Renderer.GetShadowMap().RecreateTexture();
});
m_ConfigHooks->Setup("shadowquality", []() {
if (CRenderer::IsInitialised())
g_Renderer.GetShadowMap().RecreateTexture();
@ -223,8 +215,8 @@ void CRenderingOptions::ReadConfigAndSetupHooks()
m_ConfigHooks->Setup("gpuskinning", [this]() {
bool enabled;
CFG_GET_VAL("gpuskinning", enabled);
if (enabled && !m_PreferGLSL)
LOGWARNING("GPUSkinning has been disabled, because it is not supported with PreferGLSL disabled.");
if (enabled && g_VideoMode.GetBackend() == CVideoMode::Backend::GL_ARB)
LOGWARNING("GPUSkinning has been disabled, because it is not supported with ARB shaders.");
else if (enabled)
m_GPUSkinning = true;
});
@ -258,23 +250,6 @@ void CRenderingOptions::SetFog(bool value)
g_Renderer.MakeShadersDirty();
}
void CRenderingOptions::SetPreferGLSL(bool value)
{
if (m_GPUSkinning && !value)
{
LOGWARNING("GPUSkinning have been disabled, because it is not supported with PreferGLSL disabled.");
m_GPUSkinning = false;
}
else if (!m_GPUSkinning && value)
CFG_GET_VAL("gpuskinning", m_GPUSkinning);
m_PreferGLSL = value;
if (!CRenderer::IsInitialised())
return;
g_Renderer.MakeShadersDirty();
g_Renderer.RecomputeSystemShaderDefines();
}
void CRenderingOptions::SetRenderPath(RenderPath value)
{
m_RenderPath = value;

1
source/renderer/RenderingOptions.h
View File

@ -98,7 +98,6 @@ OPTION_CUSTOM_SETTER(NAME, TYPE); OPTION_GETTER(NAME, TYPE); OPTION_DEF(NAME, TY
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);

3
source/renderer/ShadowMap.cpp
View File

@ -34,6 +34,7 @@
#include "ps/ConfigDB.h"
#include "ps/CStrInternStatic.h"
#include "ps/Profile.h"
#include "ps/VideoMode.h"
#include "renderer/DebugRenderer.h"
#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
@ -127,7 +128,7 @@ void ShadowMapInternals::UpdateCascadesParameters()
CascadeCount = 1;
CFG_GET_VAL("shadowscascadecount", CascadeCount);
if (CascadeCount < 1 || CascadeCount > MAX_CASCADE_COUNT || !g_RenderingOptions.GetPreferGLSL())
if (CascadeCount < 1 || CascadeCount > MAX_CASCADE_COUNT || g_VideoMode.GetBackend() == CVideoMode::Backend::GL_ARB)
CascadeCount = 1;
ShadowsCoverMap = false;

3
source/renderer/TerrainRenderer.cpp
View File

@ -369,8 +369,7 @@ bool TerrainRenderer::RenderFancyWater(const CShaderDefines& context, int cullGr
if (waterManager->m_WaterReflection)
defines.Add(str_USE_REFLECTION, str_1);
m->fancyWaterTech = g_Renderer.GetShaderManager().LoadEffect(
str_water_high, g_Renderer.GetSystemShaderDefines(), defines);
m->fancyWaterTech = g_Renderer.GetShaderManager().LoadEffect(str_water_high, defines);
if (!m->fancyWaterTech)
{

3
source/renderer/WaterManager.cpp
View File

@ -30,6 +30,7 @@
#include "ps/CLogger.h"
#include "ps/CStrInternStatic.h"
#include "ps/Game.h"
#include "ps/VideoMode.h"
#include "ps/World.h"
#include "renderer/WaterManager.h"
#include "renderer/Renderer.h"
@ -1090,7 +1091,7 @@ void WaterManager::UpdateQuality()
bool WaterManager::WillRenderFancyWater() const
{
return
m_RenderWater && g_RenderingOptions.GetPreferGLSL() &&
m_RenderWater && g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB &&
g_RenderingOptions.GetWaterEffects() && g_Renderer.GetCapabilities().m_PrettyWater;
}

24
source/tools/atlas/AtlasUI/ScenarioEditor/ScenarioEditor.cpp
View File

@ -343,8 +343,6 @@ enum
ID_BigScreenshot,
ID_JavaScript,
ID_CameraReset,
ID_RenderPathShaderARB,
ID_RenderPathShaderGLSL,
ID_DumpState,
ID_DumpBinaryState,
@ -379,8 +377,6 @@ BEGIN_EVENT_TABLE(ScenarioEditor, wxFrame)
EVT_MENU(ID_CameraReset, ScenarioEditor::OnCameraReset)
EVT_MENU(ID_DumpState, ScenarioEditor::OnDumpState)
EVT_MENU(ID_DumpBinaryState, ScenarioEditor::OnDumpState)
EVT_MENU(ID_RenderPathShaderARB, ScenarioEditor::OnRenderPath)
EVT_MENU(ID_RenderPathShaderGLSL, ScenarioEditor::OnRenderPath)
EVT_MENU(ID_Manual, ScenarioEditor::OnHelp)
EVT_MENU(ID_ReportBug, ScenarioEditor::OnHelp)
@ -499,11 +495,6 @@ ScenarioEditor::ScenarioEditor(wxWindow* parent)
menuMisc->AppendSubMenu(menuSS, _("Si&mulation state"));
menuSS->Append(ID_DumpState, _("&Dump to disk"));
menuSS->Append(ID_DumpBinaryState, _("Dump &binary to disk"));
wxMenu *menuRP = new wxMenu;
menuMisc->AppendSubMenu(menuRP, _("Render &path"));
menuRP->Append(ID_RenderPathShaderARB, _("Shader &ARB"));
menuRP->Append(ID_RenderPathShaderGLSL, _("&Shader GLSL (default)"));
}
wxMenu *menuHelp = new wxMenu;
@ -958,21 +949,6 @@ void ScenarioEditor::OnCameraReset(wxCommandEvent& WXUNUSED(event))
POST_MESSAGE(CameraReset, ());
}
void ScenarioEditor::OnRenderPath(wxCommandEvent& event)
{
switch (event.GetId())
{
case ID_RenderPathShaderARB:
POST_MESSAGE(SetViewParamS, (eRenderView::GAME, L"renderpath", L"shader"));
POST_MESSAGE(SetViewParamB, (eRenderView::GAME, L"preferGLSL", false));
break;
case ID_RenderPathShaderGLSL:
POST_MESSAGE(SetViewParamS, (eRenderView::GAME, L"renderpath", L"shader"));
POST_MESSAGE(SetViewParamB, (eRenderView::GAME, L"preferGLSL", true));
break;
}
}
void ScenarioEditor::OnDumpState(wxCommandEvent& event)
{
wxDateTime time = wxDateTime::Now();

3
source/tools/atlas/AtlasUI/ScenarioEditor/ScenarioEditor.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2017 Wildfire Games.
/* Copyright (C) 2021 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
@ -57,7 +57,6 @@ public:
void OnMediaPlayer(wxCommandEvent& event);
void OnJavaScript(wxCommandEvent& event);
void OnCameraReset(wxCommandEvent& event);
void OnRenderPath(wxCommandEvent& event);
void OnDumpState(wxCommandEvent& event);
void OnSelectedObjectsChange(const std::vector<AtlasMessage::ObjectID>& selectedObjects);

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

@ -283,8 +283,6 @@ void AtlasViewGame::SetParam(const std::wstring& name, bool value)
g_Renderer.SetDisplayTerrainPriorities(value);
else if (name == L"movetool")
m_DrawMoveTool = value;
else if (name == L"preferGLSL")
g_RenderingOptions.SetPreferGLSL(value);
}
void AtlasViewGame::SetParam(const std::wstring& name, float value)
@ -312,10 +310,6 @@ void AtlasViewGame::SetParam(const std::wstring& name, const std::wstring& value
cmpPathfinder->SetAtlasOverlay(false);
}
}
else if (name == L"renderpath")
{
g_RenderingOptions.SetRenderPath(RenderPathEnum::FromString(CStrW(value).ToUTF8()));
}
}
CCamera& AtlasViewGame::GetCamera()