Differential D2293 Diff 14122 ps/trunk/source/renderer/RenderingOptions.cpp

Changeset View

Standalone View

ps/trunk/source/renderer/RenderingOptions.cpp

Show All 17 Lines
#include "precompiled.h"		#include "precompiled.h"

#include "RenderingOptions.h"		#include "RenderingOptions.h"

#include "ps/CLogger.h"		#include "ps/CLogger.h"
#include "ps/ConfigDB.h"		#include "ps/ConfigDB.h"
#include "ps/CStr.h"		#include "ps/CStr.h"
#include "renderer/Renderer.h"		#include "renderer/Renderer.h"
		#include "renderer/PostprocManager.h"
		#include "renderer/ShadowMap.h"

SRenderingOptions g_RenderingOptions;		CRenderingOptions g_RenderingOptions;

		class CRenderingOptions::ConfigHooks
		{
		public:
		std::vector<CConfigDB::hook_t>::iterator begin() { return hooks.begin(); }
		std::vector<CConfigDB::hook_t>::iterator end() { return hooks.end(); }
		void insert(CConfigDB::hook_t&& hook) { return hooks.emplace_back(std::move(hook)); }
		private:
		std::vector<CConfigDB::hook_t> hooks;
		};

RenderPath RenderPathEnum::FromString(const CStr8& name)		RenderPath RenderPathEnum::FromString(const CStr8& name)
{		{
if (name == "default")		if (name == "default")
return DEFAULT;		return DEFAULT;
if (name == "fixed")		if (name == "fixed")
return FIXED;		return FIXED;
if (name == "shader")		if (name == "shader")
Show All 12 Lines	CStr8 RenderPathEnum::ToString(RenderPath path)
case RenderPath::FIXED:		case RenderPath::FIXED:
return "fixed";		return "fixed";
case RenderPath::SHADER:		case RenderPath::SHADER:
return "shader";		return "shader";
}		}
return "default"; // Silence warning about reaching end of non-void function.		return "default"; // Silence warning about reaching end of non-void function.
}		}

SRenderingOptions::SRenderingOptions()		CRenderingOptions::CRenderingOptions() : m_ConfigHooks(new ConfigHooks())
{		{
m_NoVBO = false;		m_NoVBO = false;
m_RenderPath = RenderPath::DEFAULT;		m_RenderPath = RenderPath::DEFAULT;
m_Shadows = false;		m_Shadows = false;
m_WaterEffects = false;		m_WaterEffects = false;
m_WaterFancyEffects = false;		m_WaterFancyEffects = false;
m_WaterRealDepth = false;		m_WaterRealDepth = false;
m_WaterRefraction = false;		m_WaterRefraction = false;
Show All 11 Lines	CRenderingOptions::CRenderingOptions() : m_ConfigHooks(new ConfigHooks())
m_SmoothLOS = false;		m_SmoothLOS = false;
m_PostProc = false;		m_PostProc = false;
m_ShowSky = false;		m_ShowSky = false;
m_DisplayFrustum = false;		m_DisplayFrustum = false;
m_DisplayShadowsFrustum = false;		m_DisplayShadowsFrustum = false;
m_RenderActors = true;		m_RenderActors = true;
}		}

void SRenderingOptions::ReadConfig()		CRenderingOptions::~CRenderingOptions()
{		{
CFG_GET_VAL("shadows", m_Shadows);		// This is currently irrelevant since CConfigDB is deleted before CRenderingOptions
CFG_GET_VAL("shadowpcf", m_ShadowPCF);		// (as only the latter is a static variable), but the check is a good idea regardless.
		if (!CConfigDB::IsInitialised())
		return;
		for (CConfigDB::hook_t& hook : *m_ConfigHooks)
		g_ConfigDB.UnregisterHook(std::move(hook));
		}

CFG_GET_VAL("preferglsl", m_PreferGLSL);		template<typename T>
CFG_GET_VAL("postproc", m_PostProc);		void CRenderingOptions::SetupConfig(CStr8 name, T& variable)
CFG_GET_VAL("smoothlos", m_SmoothLOS);		{
		m_ConfigHooks->insert(g_ConfigDB.RegisterHookAndCall(name, [name, &variable]() { CFG_GET_VAL(name, variable); }));
		}

CStr renderPath;		void CRenderingOptions::SetupConfig(CStr8 name, std::function<void()> hook)
CFG_GET_VAL("renderpath", renderPath);		{
SetRenderPath(RenderPathEnum::FromString(renderPath));		m_ConfigHooks->insert(g_ConfigDB.RegisterHookAndCall(name, hook));
		}

CFG_GET_VAL("watereffects", m_WaterEffects);		void CRenderingOptions::ReadConfig()
CFG_GET_VAL("waterfancyeffects", m_WaterFancyEffects);		{
CFG_GET_VAL("waterrealdepth", m_WaterRealDepth);		SetupConfig("preferglsl", [this]() {
CFG_GET_VAL("waterrefraction", m_WaterRefraction);		bool enabled;
CFG_GET_VAL("waterreflection", m_WaterReflection);		CFG_GET_VAL("preferglsl", enabled);
CFG_GET_VAL("watershadows", m_WaterShadows);		SetPreferGLSL(enabled);
		});
CFG_GET_VAL("particles", m_Particles);
CFG_GET_VAL("fog", m_Fog);
CFG_GET_VAL("silhouettes", m_Silhouettes);
CFG_GET_VAL("showsky", m_ShowSky);

CFG_GET_VAL("novbo", m_NoVBO);		SetupConfig("shadowquality", []() {
		g_Renderer.GetShadowMap().RecreateTexture();
		});

CFG_GET_VAL("forcealphatest", m_ForceAlphaTest);		SetupConfig("shadows", [this]() {
CFG_GET_VAL("gpuskinning", m_GPUSkinning);		bool enabled;
		CFG_GET_VAL("shadows", enabled);
		SetShadows(enabled);
		});
		SetupConfig("shadowpcf", [this]() {
		bool enabled;
		CFG_GET_VAL("shadowpcf", enabled);
		SetShadowPCF(enabled);
		});

CFG_GET_VAL("renderactors", m_RenderActors);		SetupConfig("antialiasing", []() {
		g_Renderer.GetPostprocManager().UpdateAntiAliasingTechnique();
		});

if (m_GPUSkinning && !m_PreferGLSL)		SetupConfig("sharpness", []() {
{		g_Renderer.GetPostprocManager().UpdateSharpnessFactor();
LOGWARNING("GPUSkinning have been disabled, because it is not supported with PreferGLSL disabled.");		});
m_GPUSkinning = false;
}		SetupConfig("sharpening", []() {
		g_Renderer.GetPostprocManager().UpdateSharpeningTechnique();
		});

		SetupConfig("postproc", m_PostProc);
		SetupConfig("smoothlos", m_SmoothLOS);

		SetupConfig("renderpath", [this]() {
		CStr renderPath;
		CFG_GET_VAL("renderpath", renderPath);
		SetRenderPath(RenderPathEnum::FromString(renderPath));
		});

		SetupConfig("watereffects", m_WaterEffects);
		SetupConfig("waterfancyeffects", m_WaterFancyEffects);
		SetupConfig("waterrealdepth", m_WaterRealDepth);
		SetupConfig("waterrefraction", m_WaterRefraction);
		SetupConfig("waterreflection", m_WaterReflection);
		SetupConfig("watershadows", m_WaterShadows);

		SetupConfig("particles", m_Particles);
		SetupConfig("fog", [this]() {
		bool enabled;
		CFG_GET_VAL("fog", enabled);
		SetFog(enabled);
		});
		SetupConfig("silhouettes", m_Silhouettes);
		SetupConfig("showsky", m_ShowSky);

		SetupConfig("novbo", m_NoVBO);

		SetupConfig("forcealphatest", m_ForceAlphaTest);
		SetupConfig("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.");
		else if (enabled)
		m_GPUSkinning = true;
		});

		SetupConfig("renderactors", m_RenderActors);
}		}

void SRenderingOptions::SetShadows(bool value)		void CRenderingOptions::SetShadows(bool value)
{		{
m_Shadows = value;		m_Shadows = value;
g_Renderer.MakeShadersDirty();		g_Renderer.MakeShadersDirty();
}		}

void SRenderingOptions::SetShadowPCF(bool value)		void CRenderingOptions::SetShadowPCF(bool value)
{		{
m_ShadowPCF = value;		m_ShadowPCF = value;
g_Renderer.MakeShadersDirty();		g_Renderer.MakeShadersDirty();
}		}

void SRenderingOptions::SetFog(bool value)		void CRenderingOptions::SetFog(bool value)
{		{
m_Fog = value;		m_Fog = value;
g_Renderer.MakeShadersDirty();		g_Renderer.MakeShadersDirty();
}		}

void SRenderingOptions::SetPreferGLSL(bool value)		void CRenderingOptions::SetPreferGLSL(bool value)
{		{
if (m_GPUSkinning && !value)		if (m_GPUSkinning && !value)
{		{
LOGWARNING("GPUSkinning have been disabled, because it is not supported with PreferGLSL disabled.");		LOGWARNING("GPUSkinning have been disabled, because it is not supported with PreferGLSL disabled.");
m_GPUSkinning = false;		m_GPUSkinning = false;
}		}
else if (!m_GPUSkinning && value)		else if (!m_GPUSkinning && value)
CFG_GET_VAL("gpuskinning", m_GPUSkinning);		CFG_GET_VAL("gpuskinning", m_GPUSkinning);

m_PreferGLSL = value;		m_PreferGLSL = value;
g_Renderer.MakeShadersDirty();		g_Renderer.MakeShadersDirty();
g_Renderer.RecomputeSystemShaderDefines();		g_Renderer.RecomputeSystemShaderDefines();
}		}


void SRenderingOptions::SetRenderPath(RenderPath value)		void CRenderingOptions::SetRenderPath(RenderPath value)
{		{
m_RenderPath = value;		m_RenderPath = value;
g_Renderer.SetRenderPath(m_RenderPath);		g_Renderer.SetRenderPath(m_RenderPath);
}		}