Line data Source code
1 : /* Copyright (C) 2022 Wildfire Games.
2 : * This file is part of 0 A.D.
3 : *
4 : * 0 A.D. is free software: you can redistribute it and/or modify
5 : * it under the terms of the GNU General Public License as published by
6 : * the Free Software Foundation, either version 2 of the License, or
7 : * (at your option) any later version.
8 : *
9 : * 0 A.D. is distributed in the hope that it will be useful,
10 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : * GNU General Public License for more details.
13 : *
14 : * You should have received a copy of the GNU General Public License
15 : * along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
16 : */
17 :
18 : #include "precompiled.h"
19 :
20 : #include "RenderingOptions.h"
21 :
22 : #include "graphics/TextureManager.h"
23 : #include "ps/CLogger.h"
24 : #include "ps/ConfigDB.h"
25 : #include "ps/CStr.h"
26 : #include "ps/CStrInternStatic.h"
27 : #include "ps/VideoMode.h"
28 : #include "renderer/Renderer.h"
29 : #include "renderer/PostprocManager.h"
30 : #include "renderer/SceneRenderer.h"
31 : #include "renderer/ShadowMap.h"
32 : #include "renderer/WaterManager.h"
33 :
34 : CRenderingOptions g_RenderingOptions;
35 :
36 0 : class CRenderingOptions::ConfigHooks
37 : {
38 : public:
39 : std::vector<CConfigDBHook>::iterator begin() { return hooks.begin(); }
40 : std::vector<CConfigDBHook>::iterator end() { return hooks.end(); }
41 : template<typename T>
42 0 : void Setup(CStr8 name, T& variable)
43 : {
44 0 : hooks.emplace_back(g_ConfigDB.RegisterHookAndCall(name, [name, &variable]() { CFG_GET_VAL(name, variable); }));
45 0 : }
46 0 : void Setup(CStr8 name, std::function<void()> hook)
47 : {
48 0 : hooks.emplace_back(g_ConfigDB.RegisterHookAndCall(name, hook));
49 0 : }
50 1 : void clear() { hooks.clear(); }
51 : private:
52 : std::vector<CConfigDBHook> hooks;
53 : };
54 :
55 0 : RenderPath RenderPathEnum::FromString(const CStr8& name)
56 : {
57 0 : if (name == "default")
58 : return DEFAULT;
59 0 : if (name == "fixed")
60 : return FIXED;
61 0 : if (name == "shader")
62 : return SHADER;
63 :
64 0 : LOGWARNING("Unknown render path %s", name.c_str());
65 0 : return DEFAULT;
66 : }
67 :
68 0 : CStr8 RenderPathEnum::ToString(RenderPath path)
69 : {
70 0 : switch (path)
71 : {
72 0 : case RenderPath::DEFAULT:
73 0 : return "default";
74 0 : case RenderPath::FIXED:
75 0 : return "fixed";
76 0 : case RenderPath::SHADER:
77 0 : return "shader";
78 : }
79 0 : return "default"; // Silence warning about reaching end of non-void function.
80 : }
81 :
82 0 : RenderDebugMode RenderDebugModeEnum::FromString(const CStr8& name)
83 : {
84 0 : if (name == str_RENDER_DEBUG_MODE_NONE.c_str())
85 : return RenderDebugMode::NONE;
86 0 : if (name == str_RENDER_DEBUG_MODE_AO.c_str())
87 : return RenderDebugMode::AO;
88 0 : if (name == str_RENDER_DEBUG_MODE_ALPHA.c_str())
89 : return RenderDebugMode::ALPHA;
90 0 : if (name == str_RENDER_DEBUG_MODE_CUSTOM.c_str())
91 : return RenderDebugMode::CUSTOM;
92 :
93 0 : LOGWARNING("Unknown render debug mode %s", name.c_str());
94 0 : return RenderDebugMode::NONE;
95 : }
96 :
97 0 : CStrIntern RenderDebugModeEnum::ToString(RenderDebugMode mode)
98 : {
99 0 : switch (mode)
100 : {
101 0 : case RenderDebugMode::AO:
102 0 : return str_RENDER_DEBUG_MODE_AO;
103 0 : case RenderDebugMode::ALPHA:
104 0 : return str_RENDER_DEBUG_MODE_ALPHA;
105 0 : case RenderDebugMode::CUSTOM:
106 0 : return str_RENDER_DEBUG_MODE_CUSTOM;
107 0 : default:
108 0 : break;
109 : }
110 0 : return str_RENDER_DEBUG_MODE_NONE;
111 : }
112 :
113 1 : CRenderingOptions::CRenderingOptions() : m_ConfigHooks(new ConfigHooks())
114 : {
115 1 : m_RenderPath = RenderPath::DEFAULT;
116 1 : m_Shadows = false;
117 1 : m_WaterEffects = false;
118 1 : m_WaterFancyEffects = false;
119 1 : m_WaterRealDepth = false;
120 1 : m_WaterRefraction = false;
121 1 : m_WaterReflection = false;
122 1 : m_ShadowAlphaFix = false;
123 1 : m_ShadowPCF = false;
124 1 : m_Particles = false;
125 1 : m_Silhouettes = false;
126 1 : m_Fog = false;
127 1 : m_GPUSkinning = false;
128 1 : m_SmoothLOS = false;
129 1 : m_PostProc = false;
130 1 : m_DisplayFrustum = false;
131 1 : m_DisplayShadowsFrustum = false;
132 1 : m_RenderActors = true;
133 1 : }
134 :
135 3 : CRenderingOptions::~CRenderingOptions()
136 : {
137 2 : ClearHooks();
138 1 : }
139 :
140 0 : void CRenderingOptions::ReadConfigAndSetupHooks()
141 : {
142 0 : m_ConfigHooks->Setup("renderpath", [this]() {
143 0 : CStr renderPath;
144 0 : CFG_GET_VAL("renderpath", renderPath);
145 0 : SetRenderPath(RenderPathEnum::FromString(renderPath));
146 0 : });
147 0 :
148 0 : m_ConfigHooks->Setup("shadowquality", []() {
149 0 : if (CRenderer::IsInitialised())
150 0 : g_Renderer.GetSceneRenderer().GetShadowMap().RecreateTexture();
151 0 : });
152 0 : m_ConfigHooks->Setup("shadowscascadecount", []() {
153 0 : if (CRenderer::IsInitialised())
154 0 : {
155 0 : g_Renderer.GetSceneRenderer().GetShadowMap().RecreateTexture();
156 0 : g_Renderer.MakeShadersDirty();
157 : }
158 0 : });
159 0 : m_ConfigHooks->Setup("shadowscovermap", []() {
160 0 : if (CRenderer::IsInitialised())
161 0 : {
162 0 : g_Renderer.GetSceneRenderer().GetShadowMap().RecreateTexture();
163 0 : g_Renderer.MakeShadersDirty();
164 0 : }
165 0 : });
166 0 : m_ConfigHooks->Setup("shadowscutoffdistance", []() {
167 0 : if (CRenderer::IsInitialised())
168 0 : g_Renderer.GetSceneRenderer().GetShadowMap().RecreateTexture();
169 0 : });
170 0 :
171 0 : m_ConfigHooks->Setup("shadows", [this]() {
172 : bool enabled;
173 0 : CFG_GET_VAL("shadows", enabled);
174 0 : SetShadows(enabled);
175 : });
176 0 : m_ConfigHooks->Setup("shadowpcf", [this]() {
177 0 : bool enabled;
178 0 : CFG_GET_VAL("shadowpcf", enabled);
179 : SetShadowPCF(enabled);
180 0 : });
181 0 :
182 : m_ConfigHooks->Setup("postproc", m_PostProc);
183 0 :
184 0 : m_ConfigHooks->Setup("antialiasing", []() {
185 0 : if (CRenderer::IsInitialised())
186 : g_Renderer.GetPostprocManager().UpdateAntiAliasingTechnique();
187 0 : });
188 0 :
189 : m_ConfigHooks->Setup("sharpness", []() {
190 0 : if (CRenderer::IsInitialised())
191 0 : g_Renderer.GetPostprocManager().UpdateSharpnessFactor();
192 0 : });
193 :
194 0 : m_ConfigHooks->Setup("sharpening", []() {
195 0 : if (CRenderer::IsInitialised())
196 : g_Renderer.GetPostprocManager().UpdateSharpeningTechnique();
197 0 : });
198 0 :
199 0 : m_ConfigHooks->Setup("smoothlos", m_SmoothLOS);
200 :
201 0 : m_ConfigHooks->Setup("watereffects", [this]() {
202 0 : bool enabled;
203 : CFG_GET_VAL("watereffects", enabled);
204 0 : SetWaterEffects(enabled);
205 0 : if (CRenderer::IsInitialised())
206 0 : g_Renderer.GetSceneRenderer().GetWaterManager().RecreateOrLoadTexturesIfNeeded();
207 : });
208 0 : m_ConfigHooks->Setup("waterfancyeffects", [this]() {
209 0 : bool enabled;
210 : CFG_GET_VAL("waterfancyeffects", enabled);
211 0 : SetWaterFancyEffects(enabled);
212 0 : if (CRenderer::IsInitialised())
213 0 : g_Renderer.GetSceneRenderer().GetWaterManager().RecreateOrLoadTexturesIfNeeded();
214 0 : });
215 0 : m_ConfigHooks->Setup("waterrealdepth", m_WaterRealDepth);
216 0 : m_ConfigHooks->Setup("waterrefraction", [this]() {
217 0 : bool enabled;
218 0 : CFG_GET_VAL("waterrefraction", enabled);
219 0 : SetWaterRefraction(enabled);
220 0 : if (CRenderer::IsInitialised())
221 0 : g_Renderer.GetSceneRenderer().GetWaterManager().RecreateOrLoadTexturesIfNeeded();
222 0 : });
223 0 : m_ConfigHooks->Setup("waterreflection", [this]() {
224 : bool enabled;
225 0 : CFG_GET_VAL("waterreflection", enabled);
226 0 : SetWaterReflection(enabled);
227 0 : if (CRenderer::IsInitialised())
228 0 : g_Renderer.GetSceneRenderer().GetWaterManager().RecreateOrLoadTexturesIfNeeded();
229 0 : });
230 0 :
231 0 : m_ConfigHooks->Setup("particles", m_Particles);
232 0 : m_ConfigHooks->Setup("fog", [this]() {
233 0 : bool enabled;
234 0 : CFG_GET_VAL("fog", enabled);
235 0 : SetFog(enabled);
236 0 : });
237 0 : m_ConfigHooks->Setup("silhouettes", m_Silhouettes);
238 0 :
239 0 : m_ConfigHooks->Setup("gpuskinning", [this]() {
240 0 : bool enabled;
241 0 : CFG_GET_VAL("gpuskinning", enabled);
242 0 : if (enabled && g_VideoMode.GetBackend() == CVideoMode::Backend::GL_ARB)
243 0 : LOGWARNING("GPUSkinning has been disabled, because it is not supported with ARB shaders.");
244 0 : else if (enabled)
245 0 : m_GPUSkinning = true;
246 0 : });
247 0 :
248 0 : m_ConfigHooks->Setup("renderactors", m_RenderActors);
249 0 :
250 0 : m_ConfigHooks->Setup("textures.quality", []() {
251 0 : if (CRenderer::IsInitialised())
252 0 : g_Renderer.GetTextureManager().OnQualityChanged();
253 0 : });
254 0 : m_ConfigHooks->Setup("textures.maxanisotropy", []() {
255 : if (CRenderer::IsInitialised())
256 0 : g_Renderer.GetTextureManager().OnQualityChanged();
257 : });
258 0 : }
259 0 :
260 0 : void CRenderingOptions::ClearHooks()
261 0 : {
262 0 : m_ConfigHooks->clear();
263 0 : }
264 0 :
265 0 : void CRenderingOptions::SetShadows(bool value)
266 0 : {
267 0 : m_Shadows = value;
268 0 : if (CRenderer::IsInitialised())
269 0 : g_Renderer.MakeShadersDirty();
270 : }
271 0 :
272 0 : void CRenderingOptions::SetShadowPCF(bool value)
273 0 : {
274 0 : m_ShadowPCF = value;
275 0 : if (CRenderer::IsInitialised())
276 0 : g_Renderer.MakeShadersDirty();
277 0 : }
278 0 :
279 0 : void CRenderingOptions::SetFog(bool value)
280 0 : {
281 0 : m_Fog = value;
282 0 : if (CRenderer::IsInitialised())
283 : g_Renderer.MakeShadersDirty();
284 0 : }
285 0 :
286 0 : void CRenderingOptions::SetRenderPath(RenderPath value)
287 0 : {
288 0 : m_RenderPath = value;
289 0 : if (CRenderer::IsInitialised())
290 0 : g_Renderer.SetRenderPath(m_RenderPath);
291 0 : }
292 0 :
293 0 : void CRenderingOptions::SetRenderDebugMode(RenderDebugMode value)
294 0 : {
295 0 : m_RenderDebugMode = value;
296 : if (CRenderer::IsInitialised())
297 0 : g_Renderer.MakeShadersDirty();
298 : }
|
