Index: binaries/data/mods/public/gui/options/options.json =================================================================== --- binaries/data/mods/public/gui/options/options.json +++ binaries/data/mods/public/gui/options/options.json @@ -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", Index: source/graphics/LOSTexture.cpp =================================================================== --- source/graphics/LOSTexture.cpp +++ source/graphics/LOSTexture.cpp @@ -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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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]); Index: source/graphics/MaterialManager.cpp =================================================================== --- source/graphics/MaterialManager.cpp +++ source/graphics/MaterialManager.cpp @@ -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 @@ -79,7 +79,7 @@ #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)); Index: source/graphics/Model.cpp =================================================================== --- source/graphics/Model.cpp +++ source/graphics/Model.cpp @@ -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 @@ // 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) { Index: source/gui/MiniMap.cpp =================================================================== --- source/gui/MiniMap.cpp +++ source/gui/MiniMap.cpp @@ -42,6 +42,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" @@ -573,7 +574,7 @@ 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 @@ -592,7 +593,7 @@ 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 } Index: source/ps/GameSetup/Config.h =================================================================== --- source/ps/GameSetup/Config.h +++ source/ps/GameSetup/Config.h @@ -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 @@ // 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; Index: source/ps/GameSetup/Config.cpp =================================================================== --- source/ps/GameSetup/Config.cpp +++ source/ps/GameSetup/Config.cpp @@ -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_PauseOnFocusLoss = false; -bool g_RenderActors = true; - bool g_Shadows = false; bool g_ShadowPCF = false; @@ -93,7 +91,6 @@ 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); Index: source/ps/GameSetup/GameSetup.cpp =================================================================== --- source/ps/GameSetup/GameSetup.cpp +++ source/ps/GameSetup/GameSetup.cpp @@ -598,41 +598,43 @@ // 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 Index: source/renderer/DecalRData.cpp =================================================================== --- source/renderer/DecalRData.cpp +++ source/renderer/DecalRData.cpp @@ -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 @@ VertexArrayIterator UV = m_UV.GetIterator(); 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) { Index: source/renderer/OverlayRenderer.cpp =================================================================== --- source/renderer/OverlayRenderer.cpp +++ source/renderer/OverlayRenderer.cpp @@ -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 @@ 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 @@ 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 @@ 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 @@ 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 @@ { 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 @@ 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 @@ 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 @@ #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()) Index: source/renderer/ParticleRenderer.cpp =================================================================== --- source/renderer/ParticleRenderer.cpp +++ source/renderer/ParticleRenderer.cpp @@ -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 @@ { // 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()); Index: source/renderer/PatchRData.cpp =================================================================== --- source/renderer/PatchRData.cpp +++ source/renderer/PatchRData.cpp @@ -370,7 +370,7 @@ 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 @@ 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;jglobalContext = 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 @@ } // 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 @@ 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 @@ // 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 @@ 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 @@ 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 @@ 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 @@ #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 @@ glFrontFace(GL_CW); - if (!m_Options.m_WaterReflection) + if (!g_RenderingOptions.GetWaterReflection()) { m->skyManager.RenderSky(); ogl_WarnIfError(); @@ -1245,7 +1073,7 @@ // 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::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 @@ GetScene().GetLOSTexture().InterpolateLOS(); - if (m_Options.m_Postproc) + if (g_RenderingOptions.GetPostProc()) { m->postprocManager.Initialize(); m->postprocManager.CaptureRenderOutput(); @@ -1503,7 +1331,7 @@ 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 @@ 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 @@ 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 @@ #endif // render debug lines - if (m_Options.m_DisplayFrustum) + if (g_RenderingOptions.GetDisplayFrustum()) { DisplayFrustum(); m->shadow.RenderDebugBounds(); @@ -1701,7 +1529,7 @@ 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 @@ m->particleManager.RenderSubmit(*this, frustum); - if (m_Options.m_Silhouettes) + if (g_RenderingOptions.GetSilhouettes()) { m->silhouetteRenderer.ComputeSubmissions(m_ViewCamera); @@ -1847,7 +1675,7 @@ 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 @@ if (waterScissor.GetVolume() > 0 && m_WaterManager->WillRenderFancyWater()) { - if (m_Options.m_WaterReflection) + if (g_RenderingOptions.GetWaterReflection()) { m_CurrentCullGroup = CULL_REFLECTIONS; @@ -1872,7 +1700,7 @@ scene.EnumerateObjects(reflectionCamera.GetFrustum(), this); } - if (m_Options.m_WaterRefraction) + if (g_RenderingOptions.GetWaterRefraction()) { m_CurrentCullGroup = CULL_REFRACTIONS; Index: source/renderer/RenderingOptions.h =================================================================== --- /dev/null +++ source/renderer/RenderingOptions.h @@ -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 . + */ + +/** + * 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 Index: source/renderer/RenderingOptions.cpp =================================================================== --- /dev/null +++ source/renderer/RenderingOptions.cpp @@ -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 . + */ + +#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); +} Index: source/renderer/ShadowMap.cpp =================================================================== --- source/renderer/ShadowMap.cpp +++ source/renderer/ShadowMap.cpp @@ -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,6 +37,7 @@ #include "maths/Matrix3D.h" #include "renderer/Renderer.h" +#include "renderer/RenderingOptions.h" #include "renderer/ShadowMap.h" @@ -439,7 +440,7 @@ Width, Height, formatname); - if (g_Renderer.m_Options.m_ShadowAlphaFix) + if (g_RenderingOptions.GetShadowAlphaFix()) { glGenTextures(1, &DummyTexture); g_Renderer.BindTexture(0, DummyTexture); @@ -498,7 +499,7 @@ 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); } @@ -526,7 +527,7 @@ 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); } } Index: source/renderer/SkyManager.cpp =================================================================== --- source/renderer/SkyManager.cpp +++ source/renderer/SkyManager.cpp @@ -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 @@ 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 @@ glEnd(); - if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER) + if (g_RenderingOptions.GetRenderPath() == RenderPath::SHADER) { skytech->EndPass(); } Index: source/renderer/TerrainRenderer.cpp =================================================================== --- source/renderer/TerrainRenderer.cpp +++ source/renderer/TerrainRenderer.cpp @@ -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 @@ 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); Index: source/renderer/WaterManager.cpp =================================================================== --- source/renderer/WaterManager.cpp +++ source/renderer/WaterManager.cpp @@ -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 @@ 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 @@ 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 @@ 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 @@ // 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; } Index: source/renderer/scripting/JSInterface_Renderer.h =================================================================== --- source/renderer/scripting/JSInterface_Renderer.h +++ source/renderer/scripting/JSInterface_Renderer.h @@ -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 @@ 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); Index: source/renderer/scripting/JSInterface_Renderer.cpp =================================================================== --- source/renderer/scripting/JSInterface_Renderer.cpp +++ source/renderer/scripting/JSInterface_Renderer.cpp @@ -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,71 +20,47 @@ #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()); -} - -void JSI_Renderer::SetRenderPath(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& name) -{ - g_Renderer.SetRenderPath(CRenderer::GetRenderPathByName(name)); -} - -void JSI_Renderer::RecreateShadowMap(ScriptInterface::CxPrivate* UNUSED(pCxPrivate)) -{ - g_Renderer.GetShadowMap().RecreateTexture(); -} - -bool JSI_Renderer::TextureExists(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::wstring& filename) -{ - return g_Renderer.GetTextureManager().TextureExists(filename); -} - #define REGISTER_BOOLEAN_SCRIPT_SETTING(NAME) \ scriptInterface.RegisterFunction("Renderer_Get" #NAME "Enabled"); \ scriptInterface.RegisterFunction("Renderer_Set" #NAME "Enabled"); void JSI_Renderer::RegisterScriptFunctions(const ScriptInterface& scriptInterface) { - scriptInterface.RegisterFunction("Renderer_GetRenderPath"); - scriptInterface.RegisterFunction("Renderer_SetRenderPath"); - scriptInterface.RegisterFunction("Renderer_RecreateShadowMap"); - scriptInterface.RegisterFunction("TextureExists"); REGISTER_BOOLEAN_SCRIPT_SETTING(Shadows); REGISTER_BOOLEAN_SCRIPT_SETTING(ShadowPCF); REGISTER_BOOLEAN_SCRIPT_SETTING(Particles); @@ -99,8 +75,33 @@ 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); + + scriptInterface.RegisterFunction("Renderer_GetRenderPath"); + scriptInterface.RegisterFunction("Renderer_SetRenderPath"); + scriptInterface.RegisterFunction("Renderer_RecreateShadowMap"); + scriptInterface.RegisterFunction("TextureExists"); } #undef REGISTER_BOOLEAN_SCRIPT_SETTING + +std::string JSI_Renderer::GetRenderPath(ScriptInterface::CxPrivate* UNUSED(pCxPrivate)) +{ + return RenderPathEnum::ToString(g_RenderingOptions.GetRenderPath()); +} + +void JSI_Renderer::SetRenderPath(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& name) +{ + g_RenderingOptions.SetRenderPath(RenderPathEnum::FromString(name)); +} + +void JSI_Renderer::RecreateShadowMap(ScriptInterface::CxPrivate* UNUSED(pCxPrivate)) +{ + g_Renderer.GetShadowMap().RecreateTexture(); +} + +bool JSI_Renderer::TextureExists(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::wstring& filename) +{ + return g_Renderer.GetTextureManager().TextureExists(filename); +} Index: source/simulation2/components/CCmpUnitRenderer.cpp =================================================================== --- source/simulation2/components/CCmpUnitRenderer.cpp +++ source/simulation2/components/CCmpUnitRenderer.cpp @@ -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 @@ 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)) Index: source/tools/atlas/GameInterface/ActorViewer.cpp =================================================================== --- source/tools/atlas/GameInterface/ActorViewer.cpp +++ source/tools/atlas/GameInterface/ActorViewer.cpp @@ -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 @@ 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 @@ 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 @@ 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; } Index: source/tools/atlas/GameInterface/View.cpp =================================================================== --- source/tools/atlas/GameInterface/View.cpp +++ source/tools/atlas/GameInterface/View.cpp @@ -347,7 +347,7 @@ } else if (name == L"renderpath") { - g_Renderer.SetRenderPath(g_Renderer.GetRenderPathByName(CStrW(value).ToUTF8())); + g_RenderingOptions.SetRenderPath(RenderPathEnum::FromString(CStrW(value).ToUTF8())); } }