Changeset 26069

Timestamp:
Dec 14, 2021, 7:34:02 AM (3 years ago)
Author:
Vladislav Belov
Message:

Replaces unclear PreferGLSL by direct renderer backend choice.

Commented By: Stan

Differential Revision: ​https://code.wildfiregames.com/D4363

Location:
ps/trunk
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • ps/trunk/binaries/data/config/default.cfg

    r26066 r26069  
    110110cursorbackend = "sdl"
    111111
    112 ; Specify the render path. This can be one of:
    113 ;   default       Automatically select one of the below, depending on system capabilities
    114 ;   fixed         Only use OpenGL fixed function pipeline
    115 ;   shader        Use vertex/fragment shaders for transform and lighting where possible
    116 ; Using 'fixed' instead of 'default' may work around some graphics-related problems,
    117 ; but will reduce performance and features when a modern graphics card is available.
     112; :
     113;   
     114;   
     115rendererbackend = "gl"
     116
     117; e.
    118118renderpath = default
    119119
    120120;;;;; EXPERIMENTAL ;;;;;
    121 ; Prefer GLSL shaders over ARB shaders. Allows fancier graphical effects.
    122 preferglsl = false
    123 
    124 ; Experimental probably-non-working GPU skinning support; requires preferglsl; use at own risk
     121; Experimental probably-non-working GPU skinning support; requires GLSL; use at own risk
    125122gpuskinning = false
    126123

  • ps/trunk/binaries/data/mods/public/gui/options/options.json

    r26030 r26069  
    178178        [
    179179            {
    180                 "type": "boolean",
    181                 "label": "Prefer GLSL",
    182                 "tooltip": "Use OpenGL 2.0 shaders (recommended).",
    183                 "config": "preferglsl"
     180                "type": "dropdown",
     181                "label": "Renderer backend",
     182                "tooltip": "Choose the renderer's backend. REQUIRES GAME RESTART",
     183                "config": "rendererbackend",
     184                "list": [
     185                    { "value": "gl", "label": "OpenGL", "tooltip": "Default OpenGL backend with GLSL. REQUIRES GAME RESTART" },
     186                    { "value": "glarb", "label": "OpenGL ARB", "tooltip": "Legacy OpenGL backend with ARB shaders. REQUIRES GAME RESTART" }
     187                ]
    184188            },
    185189            {
    … …  
    187191                "label": "Fog",
    188192                "tooltip": "Enable fog.",
    189                 "dependencies": ["preferglsl"],
     193                "dependencies": [],
    190194                "config": "fog"
    191195            },
    … …  
    200204                "label": "Antialiasing",
    201205                "tooltip": "Reduce aliasing effect on edges.",
    202                 "dependencies": ["postproc", "preferglsl"],
     206                "dependencies": ["postproc", ],
    203207                "config": "antialiasing",
    204208                "list": [
    … …  
    215219                "label": "Sharpening",
    216220                "tooltip": "Reduce blurry effects.",
    217                 "dependencies": ["postproc", "preferglsl"],
     221                "dependencies": ["postproc", ],
    218222                "config": "sharpening",
    219223                "list": [
    … …  
    226230                "label": "Sharpness factor",
    227231                "tooltip": "The sharpness of the choosen pass.",
    228                 "dependencies": ["postproc", "preferglsl", { "config": "sharpening", "op": "!=", "value": "disabled" }],
     232                "dependencies": [
     233                    "postproc",
     234                    { "config": "rendererbackend", "op": "!=", "value": "glarb" },
     235                    { "config": "sharpening", "op": "!=", "value": "disabled" }
     236                ],
    229237                "config": "sharpness",
    230238                "min": 0,

  • ps/trunk/source/graphics/Canvas2D.cpp

    r25704 r26069  
    7777
    7878        CShaderDefines defines;
    79         Tech = g_Renderer.GetShaderManager().LoadEffect(
    80             str_canvas2d, g_Renderer.GetSystemShaderDefines(), defines);
     79        Tech = g_Renderer.GetShaderManager().LoadEffect(str_canvas2d, defines);
    8180        ENSURE(Tech);
    8281        Tech->BeginPass();

  • ps/trunk/source/graphics/MiniMapTexture.cpp

    r26046 r26069  
    365365    baseDefines.Add(str_MINIMAP_BASE, str_1);
    366366
    367     tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), baseDefines);
     367    tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, baseDefines);
    368368    tech->BeginPass();
    369369    shader = tech->GetShader();
    … …  
    416416    CShaderDefines pointDefines;
    417417    pointDefines.Add(str_MINIMAP_POINT, str_1);
    418     tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), pointDefines);
     418    tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, pointDefines);
    419419    tech->BeginPass();
    420420    shader = tech->GetShader();

  • ps/trunk/source/graphics/ShaderManager.cpp

    r26020 r26069  
    3232#include "ps/XML/Xeromyces.h"
    3333#include "ps/XML/XMLWriter.h"
     34
    3435#include "renderer/Renderer.h"
    3536#include "renderer/RenderingOptions.h"
    … …  
    159160
    160161    const bool isGLSL = (Root.GetAttributes().GetNamedItem(at_type) == "glsl");
    161     if (!isGLSL && g_RenderingOptions.GetPreferGLSL())
     162    if (!isGLSL && g_)
    162163        LOGWARNING("CShaderManager::NewProgram: '%s': trying to load a non-GLSL program with enabled GLSL", name);
    163164
    … …  
    336337    size_t hash = 0;
    337338    hash_combine(hash, key.name.GetHash());
    338     hash_combine(hash, key.defines1.GetHash());
    339     hash_combine(hash, key.defines2.GetHash());
     339    hash_combine(hash, key.defines.GetHash());
    340340    return hash;
    341341}
    … …  
    343343bool CShaderManager::EffectCacheKey::operator==(const EffectCacheKey& b) const
    344344{
    345     return (name == b.name && defines1 == b.defines1 && defines2 == b.defines2);
     345    return ;
    346346}
    347347
    348348CShaderTechniquePtr CShaderManager::LoadEffect(CStrIntern name)
    349349{
    350     return LoadEffect(name, g_Renderer.GetSystemShaderDefines(), CShaderDefines());
    351 }
    352 
    353 CShaderTechniquePtr CShaderManager::LoadEffect(CStrIntern name, const CShaderDefines& defines1, const CShaderDefines& defines2)
     350    return LoadEffect(name, CShaderDefines());
     351}
     352
     353CShaderTechniquePtr CShaderManager::LoadEffect(CStrIntern name, const CShaderDefines& defines)
    354354{
    355355    // Return the cached effect, if there is one
    356     EffectCacheKey key = { name, defines1, defines2 };
     356    EffectCacheKey key = { name, defines };
    357357    EffectCacheMap::iterator it = m_EffectCache.find(key);
    358358    if (it != m_EffectCache.end())
    … …  
    360360
    361361    // First time we've seen this key, so construct a new effect:
    362 
    363     // Merge the two sets of defines, so NewEffect doesn't have to care about the split
    364     CShaderDefines defines(defines1);
    365     defines.SetMany(defines2);
    366 
    367362    CShaderTechniquePtr tech(new CShaderTechnique());
    368363    if (!NewEffect(name.c_str(), defines, tech))
    … …  
    412407
    413408    // Read some defines that influence how we pick techniques
    414     bool hasARB = (baseDefines.GetInt("SYS_HAS_ARB") != 0);
    415     bool hasGLSL = (baseDefines.GetInt("SYS_HAS_GLSL") != 0);
    416     bool preferGLSL = (baseDefines.GetInt("SYS_PREFER_GLSL") != 0);
     409    const CRenderer::Caps& capabilities = g_Renderer.GetCapabilities();
     410    const bool hasARB = capabilities.m_ARBProgram;
     411    const bool hasGLSL = capabilities.m_FragmentShader && capabilities.m_VertexShader;
     412    const bool preferGLSL = g_VideoMode.GetBackend() != CVideoMode::Backend::GL_ARB;
    417413
    418414    // Prepare the preprocessor for conditional tests
    … …  
    424420    // Find all the techniques that we can use, and their preference
    425421
    426     std::vector<std::pair<XMBElement, int> > usableTechs;
     422    std::vector<std::pair<XMBElement, int>> usableTechs;
    427423
    428424    XERO_ITER_EL(Root, Technique)

  • ps/trunk/source/graphics/ShaderManager.h

    r26020 r26069  
    4343     * Effects can be implemented via many techniques; this returns the best usable technique.
    4444     * @param name name of effect XML specification (file is loaded from shaders/effects/${name}.xml)
    45      * @param defines1,defines2 key/value set of preprocessor definitions; defines2 has higher precedence
     45     * @param defines
    4646     * @return loaded technique, or empty technique on error
    4747     */
    48     CShaderTechniquePtr LoadEffect(CStrIntern name, const CShaderDefines& defines1, const CShaderDefines& defines2);
     48    CShaderTechniquePtr LoadEffect(CStrIntern name, const CShaderDefines& defines);
    4949
    5050    /**
    … …  
    8888    {
    8989        CStrIntern name;
    90         CShaderDefines defines1;
    91         CShaderDefines defines2;
     90        CShaderDefines defines;
    9291
    9392        bool operator==(const EffectCacheKey& b) const;

  • ps/trunk/source/gui/ObjectTypes/CMiniMap.cpp

    r26001 r26069  
    410410        baseDefines.Add(str_MINIMAP_BASE, str_1);
    411411
    412         tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), baseDefines);
     412        tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, baseDefines);
    413413        tech->BeginPass();
    414414        shader = tech->GetShader();

  • ps/trunk/source/ps/CStrInternStatic.h

    r26020 r26069  
    6363X(RENDER_DEBUG_MODE_NONE)
    6464X(SHADOWS_CASCADE_COUNT)
    65 X(SYS_HAS_ARB)
    66 X(SYS_HAS_GLSL)
    67 X(SYS_PREFER_GLSL)
    6865X(USE_FANCY_EFFECTS)
    6966X(USE_FP_SHADOW)

  • ps/trunk/source/ps/VideoMode.cpp

    r26051 r26069  
    232232    CFG_GET_VAL("hidpi", m_ConfigEnableHiDPI);
    233233    CFG_GET_VAL("vsync", m_ConfigVSync);
     234
     235
     236
     237
     238
     239
     240
    234241}
    235242

  • ps/trunk/source/ps/VideoMode.h

    r26031 r26069  
    2929{
    3030public:
     31
     32
     33
     34
     35
     36
    3137    CVideoMode();
    3238    ~CVideoMode();
    … …  
    105111    void ResetCursor();
    106112
     113
     114
    107115private:
    108116    void ReadConfig();
    … …  
    158166    class CCursor;
    159167    std::unique_ptr<CCursor> m_Cursor;
     168
     169
    160170};
    161171

  • ps/trunk/source/renderer/DecalRData.cpp

    r25982 r26069  
    115115        }
    116116
     117
     118
    117119        CShaderTechniquePtr techBase = g_Renderer.GetShaderManager().LoadEffect(
    118             material.GetShaderEffect(), contextDecal, material.GetShaderDefines(0));
     120            material.GetShaderEffect(), );
    119121        if (!techBase)
    120122        {

  • ps/trunk/source/renderer/ModelRenderer.cpp

    r26045 r26069  
    490490        for (MaterialBuckets_t::iterator it = materialBuckets.begin(); it != materialBuckets.end(); ++it)
    491491        {
    492             CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(it->first.effect, context, it->first.defines);
     492            CShaderDefines defines = context;
     493            defines.SetMany(it->first.defines);
     494            CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(it->first.effect, defines);
    493495
    494496            // Skip invalid techniques (e.g. from data file errors)

  • ps/trunk/source/renderer/OverlayRenderer.cpp

    r26020 r26069  
    5050CShaderTechniquePtr GetOverlayLineShaderTechnique(const CShaderDefines& defines)
    5151{
    52     return g_Renderer.GetShaderManager().LoadEffect(
    53         str_overlay_line, g_Renderer.GetSystemShaderDefines(), defines);
     52    return g_Renderer.GetShaderManager().LoadEffect(str_overlay_line, defines);
    5453}
    5554

  • ps/trunk/source/renderer/ParticleRenderer.cpp

    r25457 r26069  
    8989    if (!m->shader)
    9090    {
    91         m->shader = g_Renderer.GetShaderManager().LoadEffect(str_particle, context, CShaderDefines());
    92         m->shaderSolid = g_Renderer.GetShaderManager().LoadEffect(str_particle_solid, context, CShaderDefines());
     91        m->shader = g_Renderer.GetShaderManager().LoadEffect(str_particle, context);
     92        m->shaderSolid = g_Renderer.GetShaderManager().LoadEffect(str_particle_solid, context);
    9393    }
    9494

  • ps/trunk/source/renderer/PatchRData.cpp

    r26017 r26069  
    3737#include "ps/Profile.h"
    3838#include "ps/Pyrogenesis.h"
     39
    3940#include "ps/World.h"
    4041#include "renderer/AlphaMapCalculator.h"
    … …  
    718719                continue;
    719720            }
     721
     722
    720723            CShaderTechniquePtr techBase = g_Renderer.GetShaderManager().LoadEffect(
    721                 material.GetShaderEffect(), context, material.GetShaderDefines(0));
     724                material.GetShaderEffect(), );
    722725
    723726            BatchElements& batch = PooledPairGet(
    … …  
    927930        if (!bestTex->GetMaterial().GetSamplers().empty())
    928931        {
     932
     933
    929934            layer.m_ShaderTech = g_Renderer.GetShaderManager().LoadEffect(
    930                 bestTex->GetMaterial().GetShaderEffect(), contextBlend, bestTex->GetMaterial().GetShaderDefines(0));
     935                bestTex->GetMaterial().GetShaderEffect(), );
    931936        }
    932937        batches.push_back(layer);
    … …  
    14111416    }
    14121417
    1413     if (m_VBWaterShore && g_RenderingOptions.GetPreferGLSL() &&
     1418    if (m_VBWaterShore && g_ &&
    14141419        g_Renderer.GetWaterManager()->m_WaterEffects &&
    14151420        g_Renderer.GetWaterManager()->m_WaterFancyEffects)

  • ps/trunk/source/renderer/PostprocManager.cpp

    r25457 r26069  
    3131#include "ps/Filesystem.h"
    3232#include "ps/Game.h"
     33
    3334#include "ps/World.h"
    3435#include "renderer/Renderer.h"
    … …  
    228229    CShaderDefines defines;
    229230    defines.Add(str_BLOOM_NOP, str_1);
    230     CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom,
    231             g_Renderer.GetSystemShaderDefines(), defines);
     231    CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom, defines);
    232232
    233233    tech->BeginPass();
    … …  
    287287    CShaderDefines defines2;
    288288    defines2.Add(str_BLOOM_PASS_H, str_1);
    289     CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom,
    290             g_Renderer.GetSystemShaderDefines(), defines2);
     289    CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom, defines2);
    291290
    292291    tech->BeginPass();
    … …  
    333332    CShaderDefines defines3;
    334333    defines3.Add(str_BLOOM_PASS_V, str_1);
    335     tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom,
    336             g_Renderer.GetSystemShaderDefines(), defines3);
     334    tech = g_Renderer.GetShaderManager().LoadEffect(str_bloom, defines3);
    337335
    338336    tech->BeginPass();
    … …  
    501499    // Don't do anything if we are using the default effect and no AA.
    502500    const bool hasEffects = m_PostProcEffect != L"default";
    503     const bool hasAA = m_AATech && g_RenderingOptions.GetPreferGLSL();
    504     const bool hasSharp = m_SharpTech && g_RenderingOptions.GetPreferGLSL();
     501    const bool hasARB = g_VideoMode.GetBackend() == CVideoMode::Backend::GL_ARB;
     502    const bool hasAA = m_AATech && !hasARB;
     503    const bool hasSharp = m_SharpTech && !hasARB;
    505504    if (!hasEffects && !hasAA && !hasSharp)
    506505        return;
    … …  
    591590void CPostprocManager::UpdateAntiAliasingTechnique()
    592591{
    593     if (!g_RenderingOptions.GetPreferGLSL() || !m_IsInitialized)
     592    if ( || !m_IsInitialized)
    594593        return;
    595594
    … …  
    625624            ogl_HaveExtension("GL_ARB_multisample") &&
    626625            ogl_HaveExtension("GL_ARB_texture_multisample") &&
    627             !m_AllowedSampleCounts.empty() &&
    628             g_RenderingOptions.GetPreferGLSL();
     626            !m_AllowedSampleCounts.empty();
    629627        if (!is_msaa_supported)
    630628        {
    … …  
    651649void CPostprocManager::UpdateSharpeningTechnique()
    652650{
    653     if (!g_RenderingOptions.GetPreferGLSL() || !m_IsInitialized)
     651    if ( || !m_IsInitialized)
    654652        return;
    655653

  • ps/trunk/source/renderer/Renderer.cpp

    r26065 r26069  
    5555#include "graphics/Texture.h"
    5656#include "graphics/TextureManager.h"
     57
    5758#include "renderer/DebugRenderer.h"
    5859#include "renderer/HWLightingModelRenderer.h"
    … …  
    478479}
    479480
    480 void CRenderer::RecomputeSystemShaderDefines()
    481 {
    482     CShaderDefines defines;
    483 
    484     if (m_Caps.m_ARBProgram)
    485         defines.Add(str_SYS_HAS_ARB, str_1);
    486 
    487     if (m_Caps.m_VertexShader && m_Caps.m_FragmentShader)
    488         defines.Add(str_SYS_HAS_GLSL, str_1);
    489 
    490     if (g_RenderingOptions.GetPreferGLSL())
    491         defines.Add(str_SYS_PREFER_GLSL, str_1);
    492 
    493     m_SystemShaderDefines = defines;
    494 }
    495 
    496481void CRenderer::ReloadShaders()
    497482{
    498483    ENSURE(m->IsOpen);
    499484
    500     m->globalContext = m_SystemShaderDefines;
     485    m->globalContext = ;
    501486
    502487    if (m_Caps.m_Shadows && g_RenderingOptions.GetShadows())
    … …  
    519504        RenderDebugModeEnum::ToString(g_RenderingOptions.GetRenderDebugMode()));
    520505
    521     if (g_RenderingOptions.GetPreferGLSL() && g_RenderingOptions.GetFog())
     506    if (g_ && g_RenderingOptions.GetFog())
    522507        m->globalContext.Add(str_USE_FOG, str_1);
    523508
    … …  
    526511    ENSURE(g_RenderingOptions.GetRenderPath() != RenderPath::FIXED);
    527512    m->Model.VertexRendererShader = ModelVertexRendererPtr(new ShaderModelVertexRenderer());
    528     m->Model.VertexInstancingShader = ModelVertexRendererPtr(new InstancingModelRenderer(false, g_RenderingOptions.GetPreferGLSL()));
     513    m->Model.VertexInstancingShader = ModelVertexRendererPtr(new InstancingModelRenderer(false, g_));
    529514
    530515    if (g_RenderingOptions.GetGPUSkinning()) // TODO: should check caps and GLSL etc too
    531516    {
    532         m->Model.VertexGPUSkinningShader = ModelVertexRendererPtr(new InstancingModelRenderer(true, g_RenderingOptions.GetPreferGLSL()));
     517        m->Model.VertexGPUSkinningShader = ModelVertexRendererPtr(new InstancingModelRenderer(true, g_));
    533518        m->Model.NormalSkinned = ModelRendererPtr(new ShaderModelRenderer(m->Model.VertexGPUSkinningShader));
    534519        m->Model.TranspSkinned = ModelRendererPtr(new ShaderModelRenderer(m->Model.VertexGPUSkinningShader));
    … …  
    581566    SetRenderPath(g_RenderingOptions.GetRenderPath());
    582567
    583     RecomputeSystemShaderDefines();
    584 
    585568    // Let component renderers perform one-time initialization after graphics capabilities and
    586569    // the shader path have been determined.
    … …  
    622605    if (rp == RenderPath::DEFAULT)
    623606    {
    624         if (m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && g_RenderingOptions.GetPreferGLSL()))
     607        if (m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && g_))
    625608            rp = RenderPath::SHADER;
    626609        else
    … …  
    630613    if (rp == RenderPath::SHADER)
    631614    {
    632         if (!(m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && g_RenderingOptions.GetPreferGLSL())))
     615        if (!(m_Caps.m_ARBProgram || (m_Caps.m_VertexShader && m_Caps.m_FragmentShader && g_)))
    633616        {
    634617            LOGWARNING("Falling back to fixed function\n");
    … …  
    641624
    642625    MakeShadersDirty();
    643     RecomputeSystemShaderDefines();
    644626
    645627    // We might need to regenerate some render data after changing path

  • ps/trunk/source/renderer/Renderer.h

    r25931 r26069  
    265265    CFontManager& GetFontManager();
    266266
    267     CShaderDefines GetSystemShaderDefines() { return m_SystemShaderDefines; }
    268 
    269267    CTimeManager& GetTimeManager();
    270268
    … …  
    356354
    357355    void ReloadShaders();
    358     void RecomputeSystemShaderDefines();
    359356
    360357    // RENDERER DATA:
    … …  
    374371    // Current overlay rendering mode.
    375372    ERenderMode m_OverlayRenderMode;
    376 
    377     CShaderDefines m_SystemShaderDefines;
    378373
    379374    SViewPort m_Viewport;

  • ps/trunk/source/renderer/RenderingOptions.cpp

    r25996 r26069  
    2424#include "ps/CStr.h"
    2525#include "ps/CStrInternStatic.h"
     26
    2627#include "renderer/Renderer.h"
    2728#include "renderer/PostprocManager.h"
    … …  
    121122    m_Particles = false;
    122123    m_Silhouettes = false;
    123     m_PreferGLSL = false;
    124124    m_Fog = false;
    125125    m_ForceAlphaTest = false;
    … …  
    145145    });
    146146
    147     m_ConfigHooks->Setup("preferglsl", [this]() {
    148         bool enabled;
    149         CFG_GET_VAL("preferglsl", enabled);
    150         SetPreferGLSL(enabled);
    151         if (CRenderer::IsInitialised())
    152             g_Renderer.GetShadowMap().RecreateTexture();
    153     });
    154 
    155147    m_ConfigHooks->Setup("shadowquality", []() {
    156148        if (CRenderer::IsInitialised())
    … …  
    224216        bool enabled;
    225217        CFG_GET_VAL("gpuskinning", enabled);
    226         if (enabled && !m_PreferGLSL)
    227             LOGWARNING("GPUSkinning has been disabled, because it is not supported with PreferGLSL disabled.");
     218        if (enabled && )
     219            LOGWARNING("GPUSkinning has been disabled, because it is not supported with .");
    228220        else if (enabled)
    229221            m_GPUSkinning = true;
    … …  
    259251}
    260252
    261 void CRenderingOptions::SetPreferGLSL(bool value)
    262 {
    263     if (m_GPUSkinning && !value)
    264     {
    265         LOGWARNING("GPUSkinning have been disabled, because it is not supported with PreferGLSL disabled.");
    266         m_GPUSkinning = false;
    267     }
    268     else if (!m_GPUSkinning && value)
    269         CFG_GET_VAL("gpuskinning", m_GPUSkinning);
    270 
    271     m_PreferGLSL = value;
    272     if (!CRenderer::IsInitialised())
    273         return;
    274     g_Renderer.MakeShadersDirty();
    275     g_Renderer.RecomputeSystemShaderDefines();
    276 }
    277 
    278253void CRenderingOptions::SetRenderPath(RenderPath value)
    279254{

  • ps/trunk/source/renderer/RenderingOptions.h

    r25996 r26069  
    9999    OPTION_WITH_SIDE_EFFECT(Shadows, bool);
    100100    OPTION_WITH_SIDE_EFFECT(ShadowPCF, bool);
    101     OPTION_WITH_SIDE_EFFECT(PreferGLSL, bool);
    102101    OPTION_WITH_SIDE_EFFECT(Fog, bool);
    103102

  • ps/trunk/source/renderer/ShadowMap.cpp

    r25712 r26069  
    3535#include "ps/CStrInternStatic.h"
    3636#include "ps/Profile.h"
     37
    3738#include "renderer/DebugRenderer.h"
    3839#include "renderer/Renderer.h"
    … …  
    128129    CFG_GET_VAL("shadowscascadecount", CascadeCount);
    129130
    130     if (CascadeCount < 1 || CascadeCount > MAX_CASCADE_COUNT || !g_RenderingOptions.GetPreferGLSL())
     131    if (CascadeCount < 1 || CascadeCount > MAX_CASCADE_COUNT || )
    131132        CascadeCount = 1;
    132133

  • ps/trunk/source/renderer/TerrainRenderer.cpp

    r26045 r26069  
    370370            defines.Add(str_USE_REFLECTION, str_1);
    371371
    372         m->fancyWaterTech = g_Renderer.GetShaderManager().LoadEffect(
    373             str_water_high, g_Renderer.GetSystemShaderDefines(), defines);
     372        m->fancyWaterTech = g_Renderer.GetShaderManager().LoadEffect(str_water_high, defines);
    374373
    375374        if (!m->fancyWaterTech)

  • ps/trunk/source/renderer/WaterManager.cpp

    r26045 r26069  
    3131#include "ps/CStrInternStatic.h"
    3232#include "ps/Game.h"
     33
    3334#include "ps/World.h"
    3435#include "renderer/WaterManager.h"
    … …  
    10911092{
    10921093    return
    1093         m_RenderWater && g_RenderingOptions.GetPreferGLSL() &&
     1094        m_RenderWater && g_ &&
    10941095        g_RenderingOptions.GetWaterEffects() && g_Renderer.GetCapabilities().m_PrettyWater;
    10951096}

  • ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/ScenarioEditor.cpp

    r25709 r26069  
    344344    ID_JavaScript,
    345345    ID_CameraReset,
    346     ID_RenderPathShaderARB,
    347     ID_RenderPathShaderGLSL,
    348346    ID_DumpState,
    349347    ID_DumpBinaryState,
    … …  
    380378    EVT_MENU(ID_DumpState, ScenarioEditor::OnDumpState)
    381379    EVT_MENU(ID_DumpBinaryState, ScenarioEditor::OnDumpState)
    382     EVT_MENU(ID_RenderPathShaderARB, ScenarioEditor::OnRenderPath)
    383     EVT_MENU(ID_RenderPathShaderGLSL, ScenarioEditor::OnRenderPath)
    384380
    385381    EVT_MENU(ID_Manual, ScenarioEditor::OnHelp)
    … …  
    500496        menuSS->Append(ID_DumpState, _("&Dump to disk"));
    501497        menuSS->Append(ID_DumpBinaryState, _("Dump &binary to disk"));
    502 
    503         wxMenu *menuRP = new wxMenu;
    504         menuMisc->AppendSubMenu(menuRP, _("Render &path"));
    505         menuRP->Append(ID_RenderPathShaderARB, _("Shader &ARB"));
    506         menuRP->Append(ID_RenderPathShaderGLSL, _("&Shader GLSL (default)"));
    507498    }
    508499
    … …  
    959950}
    960951
    961 void ScenarioEditor::OnRenderPath(wxCommandEvent& event)
    962 {
    963     switch (event.GetId())
    964     {
    965     case ID_RenderPathShaderARB:
    966         POST_MESSAGE(SetViewParamS, (eRenderView::GAME, L"renderpath", L"shader"));
    967         POST_MESSAGE(SetViewParamB, (eRenderView::GAME, L"preferGLSL", false));
    968         break;
    969     case ID_RenderPathShaderGLSL:
    970         POST_MESSAGE(SetViewParamS, (eRenderView::GAME, L"renderpath", L"shader"));
    971         POST_MESSAGE(SetViewParamB, (eRenderView::GAME, L"preferGLSL", true));
    972         break;
    973     }
    974 }
    975 
    976952void ScenarioEditor::OnDumpState(wxCommandEvent& event)
    977953{

  • ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/ScenarioEditor.h

    r24361 r26069  
    1 /* Copyright (C) 2017 Wildfire Games.
     1/* Copyright (C) 20 Wildfire Games.
    22 * This file is part of 0 A.D.
    33 *
    … …  
    5858    void OnJavaScript(wxCommandEvent& event);
    5959    void OnCameraReset(wxCommandEvent& event);
    60     void OnRenderPath(wxCommandEvent& event);
    6160    void OnDumpState(wxCommandEvent& event);
    6261    void OnSelectedObjectsChange(const std::vector<AtlasMessage::ObjectID>& selectedObjects);

  • ps/trunk/source/tools/atlas/GameInterface/View.cpp

    r25960 r26069  
    284284    else if (name == L"movetool")
    285285        m_DrawMoveTool = value;
    286     else if (name == L"preferGLSL")
    287         g_RenderingOptions.SetPreferGLSL(value);
    288286}
    289287
    … …  
    312310                cmpPathfinder->SetAtlasOverlay(false);
    313311        }
    314     }
    315     else if (name == L"renderpath")
    316     {
    317         g_RenderingOptions.SetRenderPath(RenderPathEnum::FromString(CStrW(value).ToUTF8()));
    318312    }
    319313}
Note: See TracChangeset for help on using the changeset viewer.