Changeset 27693

Timestamp:
Jun 14, 2023, 9:06:22 AM (14 months ago)
Author:
Vladislav Belov
Message:

Decouples renderer code from VideoMode to get backend device.

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

Location:
ps/trunk/source
Files:
25 edited

Legend:

Unmodified
Added
Removed

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

    r27232 r27693  
    1 /* Copyright (C) 2022 Wildfire Games.
     1/* Copyright (C) 202 Wildfire Games.
    22 * This file is part of 0 A.D.
    33 *
    … …  
    6868    NONCOPYABLE(CGameViewImpl);
    6969public:
    70     CGameViewImpl(CGame* game)
     70    CGameViewImpl(CGame* game)
    7171        : Game(game),
    7272        ColladaManager(g_VFS), MeshManager(ColladaManager), SkeletonAnimManager(ColladaManager),
    … …  
    7474        LOSTexture(*game->GetSimulation2()),
    7575        TerritoryTexture(*game->GetSimulation2()),
    76         MiniMapTexture(*game->GetSimulation2()),
     76        MiniMapTexture(*game->GetSimulation2()),
    7777        ViewCamera(),
    7878        CullCamera(),
    … …  
    159159#undef IMPLEMENT_BOOLEAN_SETTING
    160160
    161 CGameView::CGameView(CGame *pGame):
    162     m(new CGameViewImpl(pGame))
     161CGameView::CGameView(CGame *pGame):
     162    m(new CGameViewImpl(pGame))
    163163{
    164164    m->CullCamera = m->ViewCamera;

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

    r27232 r27693  
    1 /* Copyright (C) 2022 Wildfire Games.
     1/* Copyright (C) 202 Wildfire Games.
    22 * This file is part of 0 A.D.
    33 *
    … …  
    3838    NONCOPYABLE(CGameView);
    3939public:
    40     CGameView(CGame *pGame);
     40    CGameView(CGame *pGame);
    4141    ~CGameView() override;
    4242

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

    r27601 r27693  
    191191}
    192192
    193 CMiniMapTexture::CMiniMapTexture(CSimulation2& simulation)
     193CMiniMapTexture::CMiniMapTexture(CSimulation2& simulation)
    194194    : m_Simulation(simulation), m_IndexArray(false),
    195195    m_VertexArray(Renderer::Backend::IBuffer::Type::VERTEX, true),
    … …  
    253253    m_QuadVertexInputLayout = g_Renderer.GetVertexInputLayout(attributes);
    254254
    255     Renderer::Backend::IDevice* device = g_VideoMode.GetBackendDevice();
    256255    m_Flipped = device->GetBackend() == Renderer::Backend::Backend::VULKAN;
    257256

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

    r27412 r27693  
    4242    NONCOPYABLE(CMiniMapTexture);
    4343public:
    44     CMiniMapTexture(CSimulation2& simulation);
     44    CMiniMapTexture(CSimulation2& simulation);
    4545    ~CMiniMapTexture();
    4646

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

    r27608 r27693  
    3232#include "ps/Profile.h"
    3333#include "ps/XML/Xeromyces.h"
    34 #include "ps/VideoMode.h"
    3534#include "renderer/backend/IDevice.h"
    36 #include "renderer/Renderer.h"
    37 #include "renderer/RenderingOptions.h"
    3835
    3936#define USE_SHADER_XML_VALIDATION 1
    … …  
    4946TIMER_ADD_CLIENT(tc_ShaderValidation);
    5047
    51 CShaderManager::CShaderManager()
     48CShaderManager::CShaderManager(Renderer::Backend::IDevice* device)
     49    : m_Device(device)
    5250{
    5351#if USE_SHADER_XML_VALIDATION
    … …  
    7674        return it->second;
    7775
    78     CShaderProgramPtr program = CShaderProgram::Create(name, defines);
     76    CShaderProgramPtr program = CShaderProgram::Create(name, defines);
    7977    if (program)
    8078    {
    … …  
    157155        return false;
    158156
    159     Renderer::Backend::IDevice* device = g_VideoMode.GetBackendDevice();
    160 
    161157    // By default we assume that we have techinques for every dummy shader.
    162     if (device->GetBackend() == Renderer::Backend::Backend::DUMMY)
     158    if (evice->GetBackend() == Renderer::Backend::Backend::DUMMY)
    163159    {
    164160        CShaderProgramPtr shaderProgram = LoadProgram(str_dummy.string(), tech->GetShaderDefines());
    … …  
    168164        passPipelineStateDesc.shaderProgram = shaderProgram->GetBackendShaderProgram();
    169165        techPasses.emplace_back(
    170             device->CreateGraphicsPipelineState(passPipelineStateDesc), shaderProgram);
     166            evice->CreateGraphicsPipelineState(passPipelineStateDesc), shaderProgram);
    171167        tech->SetPasses(std::move(techPasses));
    172168        return true;
    … …  
    234230                if (attrs.GetNamedItem(at_shaders) == "arb")
    235231                {
    236                     if (device->GetBackend() != Renderer::Backend::Backend::GL_ARB ||
    237                         !device->GetCapabilities().ARBShaders)
     232                    if (evice->GetBackend() != Renderer::Backend::Backend::GL_ARB ||
     233                        !evice->GetCapabilities().ARBShaders)
    238234                    {
    239235                        isUsable = false;
    … …  
    242238                else if (attrs.GetNamedItem(at_shaders) == "glsl")
    243239                {
    244                     if (device->GetBackend() != Renderer::Backend::Backend::GL)
     240                    if (evice->GetBackend() != Renderer::Backend::Backend::GL)
    245241                        isUsable = false;
    246242                }
    247243                else if (attrs.GetNamedItem(at_shaders) == "spirv")
    248244                {
    249                     if (device->GetBackend() != Renderer::Backend::Backend::VULKAN)
     245                    if (evice->GetBackend() != Renderer::Backend::Backend::VULKAN)
    250246                        isUsable = false;
    251247                }
    … …  
    444440                passPipelineStateDesc.shaderProgram = shaderProgram->GetBackendShaderProgram();
    445441                techPasses.emplace_back(
    446                     device->CreateGraphicsPipelineState(passPipelineStateDesc), shaderProgram);
     442                    evice->CreateGraphicsPipelineState(passPipelineStateDesc), shaderProgram);
    447443            }
    448444        }

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

    r27328 r27693  
    1 /* Copyright (C) 2022 Wildfire Games.
     1/* Copyright (C) 202 Wildfire Games.
    22 * This file is part of 0 A.D.
    33 *
    … …  
    3838{
    3939public:
    40     CShaderManager();
     40    CShaderManager();
    4141    ~CShaderManager();
    4242
    … …  
    8181        }
    8282    };
     83
     84
    8385
    8486    // A CShaderProgram contains expensive backend state, so we ought to cache it.

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

    r26869 r27693  
    1 /* Copyright (C) 2022 Wildfire Games.
     1/* Copyright (C) 202 Wildfire Games.
    22 * This file is part of 0 A.D.
    33 *
    … …  
    2020#include "ShaderProgram.h"
    2121
    22 #include "ps/VideoMode.h"
    2322#include "renderer/backend/IDevice.h"
    2423
    25 CShaderProgram::CShaderProgram(const CStr& name, const CShaderDefines& defines)
    26     : m_Name(name), m_Defines(defines)
     24CShaderProgram::CShaderProgram(
     25    Renderer::Backend::IDevice* device, const CStr& name, const CShaderDefines& defines)
     26    : m_Device(device), m_Name(name), m_Defines(defines)
    2727{
    2828}
    2929
    3030// static
    31 CShaderProgramPtr CShaderProgram::Create(const CStr& name, const CShaderDefines& defines)
     31CShaderProgramPtr CShaderProgram::Create(
     32    Renderer::Backend::IDevice* device, const CStr& name, const CShaderDefines& defines)
    3233{
    33     CShaderProgramPtr shaderProgram(new CShaderProgram(name, defines));
     34    CShaderProgramPtr shaderProgram(new CShaderProgram(name, defines));
    3435    shaderProgram->Reload();
    3536    return shaderProgram->m_BackendShaderProgram ? shaderProgram : nullptr;
    … …  
    3940{
    4041    std::unique_ptr<Renderer::Backend::IShaderProgram> backendShaderProgram =
    41         g_VideoMode.GetBackendDevice()->CreateShaderProgram(m_Name, m_Defines);
     42        ->CreateShaderProgram(m_Name, m_Defines);
    4243    if (backendShaderProgram)
    4344        m_BackendShaderProgram = std::move(backendShaderProgram);

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

    r26848 r27693  
    1 /* Copyright (C) 2022 Wildfire Games.
     1/* Copyright (C) 202 Wildfire Games.
    22 * This file is part of 0 A.D.
    33 *
    … …  
    3636
    3737public:
    38     static CShaderProgramPtr Create(const CStr& name, const CShaderDefines& defines);
     38    static CShaderProgramPtr Create(
     39        Renderer::Backend::IDevice* device, const CStr& name, const CShaderDefines& defines);
    3940
    4041    void Reload();
    … …  
    4748
    4849protected:
    49     CShaderProgram(const CStr& name, const CShaderDefines& defines);
     50    CShaderProgram(
     51        Renderer::Backend::IDevice* device, const CStr& name, const CShaderDefines& defines);
    5052
     53
    5154    CStr m_Name;
    5255    CShaderDefines m_Defines;

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

    r27152 r27693  
    1 /* Copyright (C) 2022 Wildfire Games.
     1/* Copyright (C) 202 Wildfire Games.
    22 * This file is part of 0 A.D.
    33 *
    … …  
    2929#include "ps/CLogger.h"
    3030#include "ps/Filesystem.h"
    31 #include "ps/VideoMode.h"
    3231#include "ps/XML/Xeromyces.h"
    3332#include "renderer/backend/IDevice.h"
    … …  
    3837#include <vector>
    3938
    40 CTerrainTextureManager::CTerrainTextureManager()
    41     : m_LastGroupIndex(0)
     39CTerrainTextureManager::CTerrainTextureManager()
     40    : m_)
    4241{
    4342    if (!VfsDirectoryExists(L"art/terrains/"))
    … …  
    293292#endif
    294293
    295     result.m_CompositeAlphaMap = g_VideoMode.GetBackendDevice()->CreateTexture2D("CompositeAlphaMap",
     294    result.m_CompositeAlphaMap = ->CreateTexture2D("CompositeAlphaMap",
    296295        Renderer::Backend::ITexture::Usage::TRANSFER_DST |
    297296            Renderer::Backend::ITexture::Usage::SAMPLED,

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

    r26858 r27693  
    1 /* Copyright (C) 2022 Wildfire Games.
     1/* Copyright (C) 202 Wildfire Games.
    22 * This file is part of 0 A.D.
    33 *
    … …  
    9595
    9696    // constructor, destructor
    97     CTerrainTextureManager();
     97    CTerrainTextureManager();
    9898    ~CTerrainTextureManager();
    9999
    … …  
    125125
    126126private:
     127
     128
    127129    // All texture entries created by this class, for easy freeing now that
    128130    // textures may be in several STextureType's
    … …  
    133135    TerrainAlphaMap m_TerrainAlphas;
    134136
    135     size_t m_LastGroupIndex;
     137    size_t m_LastGroupIndex;
    136138
    137139    // A way to separate file loading and uploading to GPU to not stall uploading.

  • ps/trunk/source/gui/tests/test_CGUIText.h

    r27077 r27693  
    5858        g_VideoMode.CreateBackendDevice(false);
    5959        m_Viewer = new CProfileViewer;
    60         m_Renderer = new CRenderer;
     60        m_Renderer = new CRenderer;
    6161    }
    6262

  • ps/trunk/source/ps/Game.cpp

    r26653 r27693  
    1 /* Copyright (C) 2022 Wildfire Games.
     1/* Copyright (C) 202 Wildfire Games.
    22 * This file is part of 0 A.D.
    33 *
    … …  
    3333#include "ps/CLogger.h"
    3434#include "ps/CStr.h"
     35
    3536#include "ps/Loader.h"
    3637#include "ps/LoaderThunks.h"
    … …  
    3839#include "ps/Replay.h"
    3940#include "ps/World.h"
    40 #include "ps/GameSetup/GameSetup.h"
     41#include "ps/.h"
    4142#include "renderer/Renderer.h"
    4243#include "renderer/SceneRenderer.h"
    … …  
    7172    m_World(new CWorld(this)),
    7273    m_Simulation2(new CSimulation2(&m_World->GetUnitManager(), g_ScriptContext, m_World->GetTerrain())),
    73     m_GameView(CRenderer::IsInitialised() ? new CGameView(this) : nullptr),
     74    // TODO: we need to remove that global dependency. Maybe the game view
     75    // should be created outside only if needed.
     76    m_GameView(CRenderer::IsInitialised() ? new CGameView(g_VideoMode.GetBackendDevice(), this) : nullptr),
    7477    m_GameStarted(false),
    7578    m_Paused(false),

  • ps/trunk/source/ps/GameSetup/GameSetup.cpp

    r27692 r27693  
    678678
    679679    // create renderer
    680     new CRenderer;
     680    new CRenderer;
    681681
    682682    InitInput();

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

    r27608 r27693  
    3030#include "ps/Filesystem.h"
    3131#include "ps/Game.h"
    32 #include "ps/VideoMode.h"
    3332#include "ps/World.h"
    3433#include "renderer/backend/IDevice.h"
    … …  
    8382} // anonymous namespace
    8483
    85 CPostprocManager::CPostprocManager()
    86     : m_IsInitialized(false), m_PostProcEffect(L"default"), m_WhichBuffer(true),
    87     m_Sharpness(0.3f), m_UsingMultisampleBuffer(false), m_MultisampleCount(0)
     84CPostprocManager::CPostprocManager(Renderer::Backend::IDevice* device)
     85    : m_Device(device), m_IsInitialized(false), m_PostProcEffect(L"default"),
     86    m_WhichBuffer(true), m_Sharpness(0.3f), m_UsingMultisampleBuffer(false),
     87    m_MultisampleCount(0)
    8888{
    8989}
    … …  
    9696bool CPostprocManager::IsEnabled() const
    9797{
    98     Renderer::Backend::IDevice* device = g_VideoMode.GetBackendDevice();
    9998    const bool isDepthStencilFormatPresent =
    100         device->GetPreferredDepthStencilFormat(
     99        evice->GetPreferredDepthStencilFormat(
    101100            Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT, true, true)
    102101                != Renderer::Backend::Format::UNDEFINED;
    103102    return
    104103        g_RenderingOptions.GetPostProc() &&
    105         device->GetBackend() != Renderer::Backend::Backend::GL_ARB &&
     104        evice->GetBackend() != Renderer::Backend::Backend::GL_ARB &&
    106105        isDepthStencilFormatPresent;
    107106}
    … …  
    146145    m_VertexInputLayout = g_Renderer.GetVertexInputLayout(attributes);
    147146
    148     const uint32_t maxSamples = g_VideoMode.GetBackendDevice()->GetCapabilities().maxSampleCount;
     147    const uint32_t maxSamples = ->GetCapabilities().maxSampleCount;
    149148    const uint32_t possibleSampleCounts[] = {2, 4, 8, 16};
    150149    std::copy_if(
    … …  
    183182    Cleanup();
    184183
    185     Renderer::Backend::IDevice* backendDevice = g_VideoMode.GetBackendDevice();
    186 
    187184    #define GEN_BUFFER_RGBA(name, w, h) \
    188         name = backendDevice->CreateTexture2D( \
     185        name = Device->CreateTexture2D( \
    189186            "PostProc" #name, \
    190187            Renderer::Backend::ITexture::Usage::SAMPLED | \
    … …  
    216213            colorAttachment.storeOp = Renderer::Backend::AttachmentStoreOp::STORE;
    217214            colorAttachment.clearColor = CColor{0.0f, 0.0f, 0.0f, 0.0f};
    218             step.framebuffer = backendDevice->CreateFramebuffer(
     215            step.framebuffer = Device->CreateFramebuffer(
    219216                "BlurScaleSteoFramebuffer", &colorAttachment, nullptr);
    220217        }
    … …  
    226223
    227224    // Allocate the Depth/Stencil texture.
    228     m_DepthTex = backendDevice->CreateTexture2D("PostProcDepthTexture",
     225    m_DepthTex = Device->CreateTexture2D("PostProcDepthTexture",
    229226        Renderer::Backend::ITexture::Usage::SAMPLED |
    230227            Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT,
    231         backendDevice->GetPreferredDepthStencilFormat(
     228        Device->GetPreferredDepthStencilFormat(
    232229            Renderer::Backend::ITexture::Usage::SAMPLED |
    233230                Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT,
    … …  
    250247    depthStencilAttachment.storeOp = Renderer::Backend::AttachmentStoreOp::STORE;
    251248
    252     m_CaptureFramebuffer = backendDevice->CreateFramebuffer("PostprocCaptureFramebuffer",
     249    m_CaptureFramebuffer = Device->CreateFramebuffer("PostprocCaptureFramebuffer",
    253250        &colorAttachment, &depthStencilAttachment);
    254251
    … …  
    256253    colorAttachment.loadOp = Renderer::Backend::AttachmentLoadOp::LOAD;
    257254    colorAttachment.storeOp = Renderer::Backend::AttachmentStoreOp::STORE;
    258     m_PingFramebuffer = backendDevice->CreateFramebuffer("PostprocPingFramebuffer",
     255    m_PingFramebuffer = Device->CreateFramebuffer("PostprocPingFramebuffer",
    259256        &colorAttachment, nullptr);
    260257
    261258    colorAttachment.texture = m_ColorTex2.get();
    262     m_PongFramebuffer = backendDevice->CreateFramebuffer("PostprocPongFramebuffer",
     259    m_PongFramebuffer = Device->CreateFramebuffer("PostprocPongFramebuffer",
    263260        &colorAttachment, nullptr);
    264261
    … …  
    480477    // Don't do anything if we are using the default effect and no AA.
    481478    const bool hasEffects = m_PostProcEffect != L"default";
    482     const bool hasARB = g_VideoMode.GetBackendDevice()->GetBackend() == Renderer::Backend::Backend::GL_ARB;
     479    const bool hasARB = ->GetBackend() == Renderer::Backend::Backend::GL_ARB;
    483480    const bool hasAA = m_AATech && !hasARB;
    484481    const bool hasSharp = m_SharpTech && !hasARB;
    … …  
    550547void CPostprocManager::UpdateAntiAliasingTechnique()
    551548{
    552     Renderer::Backend::IDevice* device = g_VideoMode.GetBackendDevice();
    553     if (device->GetBackend() == Renderer::Backend::Backend::GL_ARB || !m_IsInitialized)
     549    if (m_Device->GetBackend() == Renderer::Backend::Backend::GL_ARB || !m_IsInitialized)
    554550        return;
    555551
    … …  
    581577        if (g_AtlasGameLoop && g_AtlasGameLoop->running)
    582578            return;
    583         if (!device->GetCapabilities().multisampling || m_AllowedSampleCounts.empty())
     579        if (!evice->GetCapabilities().multisampling || m_AllowedSampleCounts.empty())
    584580        {
    585581            LOGWARNING("MSAA is unsupported.");
    … …  
    591587                std::end(m_AllowedSampleCounts))
    592588        {
    593             m_MultisampleCount = std::min(4u, device->GetCapabilities().maxSampleCount);
     589            m_MultisampleCount = std::min(4u, evice->GetCapabilities().maxSampleCount);
    594590            LOGWARNING("Wrong MSAA sample count: %s.", m_AAName.EscapeToPrintableASCII().c_str());
    595591        }
    … …  
    601597void CPostprocManager::UpdateSharpeningTechnique()
    602598{
    603     if (g_VideoMode.GetBackendDevice()->GetBackend() == Renderer::Backend::Backend::GL_ARB || !m_IsInitialized)
     599    if (->GetBackend() == Renderer::Backend::Backend::GL_ARB || !m_IsInitialized)
    604600        return;
    605601
    … …  
    630626void CPostprocManager::CreateMultisampleBuffer()
    631627{
    632     Renderer::Backend::IDevice* backendDevice = g_VideoMode.GetBackendDevice();
    633 
    634     m_MultisampleColorTex = backendDevice->CreateTexture("PostProcColorMS",
     628    m_MultisampleColorTex = m_Device->CreateTexture("PostProcColorMS",
    635629        Renderer::Backend::ITexture::Type::TEXTURE_2D_MULTISAMPLE,
    636630        Renderer::Backend::ITexture::Usage::COLOR_ATTACHMENT |
    … …  
    642636
    643637    // Allocate the Depth/Stencil texture.
    644     m_MultisampleDepthTex = backendDevice->CreateTexture("PostProcDepthMS",
     638    m_MultisampleDepthTex = Device->CreateTexture("PostProcDepthMS",
    645639        Renderer::Backend::ITexture::Type::TEXTURE_2D_MULTISAMPLE,
    646640        Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT |
    647641            Renderer::Backend::ITexture::Usage::TRANSFER_SRC,
    648         backendDevice->GetPreferredDepthStencilFormat(
     642        Device->GetPreferredDepthStencilFormat(
    649643            Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT |
    650644                Renderer::Backend::ITexture::Usage::TRANSFER_SRC,
    … …  
    667661    depthStencilAttachment.storeOp = Renderer::Backend::AttachmentStoreOp::STORE;
    668662
    669     m_MultisampleFramebuffer = backendDevice->CreateFramebuffer(
     663    m_MultisampleFramebuffer = Device->CreateFramebuffer(
    670664        "PostprocMultisampleFramebuffer", &colorAttachment, &depthStencilAttachment);
    671665

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

    r27363 r27693  
    3232{
    3333public:
    34     CPostprocManager();
     34    CPostprocManager();
    3535    ~CPostprocManager();
    3636
    … …  
    9191    void CreateMultisampleBuffer();
    9292    void DestroyMultisampleBuffer();
     93
     94
    9395
    9496    std::unique_ptr<Renderer::Backend::IFramebuffer> m_CaptureFramebuffer;

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

    r27613 r27693  
    244244    NONCOPYABLE(Internals);
    245245public:
     246
     247
    246248    std::unique_ptr<Renderer::Backend::IDeviceCommandContext> deviceCommandContext;
    247249
    … …  
    282284        std::unique_ptr<Renderer::Backend::IVertexInputLayout>, VertexAttributesHash> vertexInputLayouts;
    283285
    284     Internals() :
     286    Internals(Renderer::Backend::IDevice* device) :
     287        device(device),
     288        deviceCommandContext(device->CreateCommandContext()),
    285289        IsOpen(false), ShadersDirty(true), profileTable(g_Renderer.m_Stats),
    286         deviceCommandContext(g_VideoMode.GetBackendDevice()->CreateCommandContext()),
    287         textureManager(g_VFS, false, g_VideoMode.GetBackendDevice())
     290        ),
     291        )
    288292    {
    289293    }
    … …  
    307311}
    308312
    309 CRenderer::CRenderer()
     313CRenderer::CRenderer()
    310314{
    311315    TIMER(L"InitRenderer");
    312316
    313     m = std::make_unique<Internals>();
     317    m = std::make_unique<Internals>();
    314318
    315319    g_ProfileViewer.AddRootTable(&m->profileTable);
    … …  
    321325
    322326    // Create terrain related stuff.
    323     new CTerrainTextureManager;
     327    new CTerrainTextureManager;
    324328
    325329    Open(g_xres, g_yres);
    … …  
    349353    ENSURE(m->IsOpen);
    350354
    351     m->sceneRenderer.ReloadShaders();
     355    m->sceneRenderer.ReloadShaders();
    352356    m->ShadersDirty = false;
    353357}
    … …  
    394398    // Renderer has been opened, so validate the selected renderpath
    395399    const bool hasShadersSupport =
    396         g_VideoMode.GetBackendDevice()->GetCapabilities().ARBShaders ||
    397         g_VideoMode.GetBackendDevice()->GetBackend() != Renderer::Backend::Backend::GL_ARB;
     400        ->GetCapabilities().ARBShaders ||
     401        ->GetBackend() != Renderer::Backend::Backend::GL_ARB;
    398402    if (rp == RenderPath::DEFAULT)
    399403    {
    … …  
    444448        {
    445449            // In case of no acquired backbuffer we have nothing render to.
    446             if (!g_VideoMode.GetBackendDevice()->AcquireNextBackbuffer())
     450            if (!->AcquireNextBackbuffer())
    447451                return;
    448452        }
    … …  
    459463        m->deviceCommandContext->Flush();
    460464        if (needsPresent)
    461             g_VideoMode.GetBackendDevice()->Present();
     465            ->Present();
    462466    }
    463467}
    … …  
    652656    const size_t bpp = 24;
    653657
    654     if (needsPresent && !g_VideoMode.GetBackendDevice()->AcquireNextBackbuffer())
     658    if (needsPresent && !->AcquireNextBackbuffer())
    655659        return;
    656660
    … …  
    670674    m->deviceCommandContext->Flush();
    671675    if (needsPresent)
    672         g_VideoMode.GetBackendDevice()->Present();
     676        ->Present();
    673677
    674678    if (tex_write(&t, filename) == INFO::OK)
    … …  
    769773            g_Game->GetView()->GetCamera()->SetProjection(projection);
    770774
    771             if (!needsPresent || g_VideoMode.GetBackendDevice()->AcquireNextBackbuffer())
     775            if (!needsPresent || ->AcquireNextBackbuffer())
    772776            {
    773777                RenderFrameImpl(false, false);
    … …  
    777781
    778782                if (needsPresent)
    779                     g_VideoMode.GetBackendDevice()->Present();
     783                    ->Present();
    780784            }
    781785
    … …  
    897901        std::vector<Renderer::Backend::SVertexAttributeFormat>{attributes.begin(), attributes.end()}, nullptr);
    898902    if (inserted)
    899         it->second = g_VideoMode.GetBackendDevice()->CreateVertexInputLayout(attributes);
     903        it->second = ->CreateVertexInputLayout(attributes);
    900904    return it->second.get();
    901905}

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

    r27363 r27693  
    7878
    7979public:
    80     CRenderer();
     80    CRenderer();
    8181    ~CRenderer();
    8282

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

    r27492 r27693  
    4343#include "ps/Game.h"
    4444#include "ps/Profile.h"
    45 #include "ps/VideoMode.h"
    4645#include "ps/World.h"
    4746#include "renderer/backend/IDevice.h"
    … …  
    7776    NONCOPYABLE(Internals);
    7877public:
    79     Internals() = default;
     78    Internals(Renderer::Backend::IDevice* device)
     79        : waterManager(device), shadow(device)
     80    {
     81    }
     82
    8083    ~Internals() = default;
    8184
    … …  
    187190};
    188191
    189 CSceneRenderer::CSceneRenderer()
    190 {
    191     m = std::make_unique<Internals>();
     192CSceneRenderer::CSceneRenderer()
     193{
     194    m = std::make_unique<Internals>();
    192195
    193196    m_TerrainRenderMode = SOLID;
    … …  
    211214}
    212215
    213 void CSceneRenderer::ReloadShaders()
     216void CSceneRenderer::ReloadShaders()
    214217{
    215218    m->globalContext = CShaderDefines();
    216 
    217     Renderer::Backend::IDevice* device = g_VideoMode.GetBackendDevice();
    218219
    219220    if (g_RenderingOptions.GetShadows())
    … …  
    568569    // Save the model-view-projection matrix so the shaders can use it for projective texturing
    569570    wm.m_ReflectionMatrix = m_ViewCamera.GetViewProjection();
    570     if (g_VideoMode.GetBackendDevice()->GetBackend() == Renderer::Backend::Backend::VULKAN)
     571    if (Device()->GetBackend() == Renderer::Backend::Backend::VULKAN)
    571572    {
    572573        CMatrix3D flip;
    … …  
    651652    wm.m_RefractionViewInvMatrix = m_ViewCamera.GetOrientation();
    652653
    653     if (g_VideoMode.GetBackendDevice()->GetBackend() == Renderer::Backend::Backend::VULKAN)
     654    if (Device()->GetBackend() == Renderer::Backend::Backend::VULKAN)
    654655    {
    655656        CMatrix3D flip;

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

    r27232 r27693  
    1 /* Copyright (C) 2022 Wildfire Games.
     1/* Copyright (C) 202 Wildfire Games.
    22 * This file is part of 0 A.D.
    33 *
    … …  
    6666    };
    6767
    68     CSceneRenderer();
     68    CSceneRenderer();
    6969    ~CSceneRenderer();
    7070
    … …  
    196196    void ResetState();
    197197
    198     void ReloadShaders();
     198    void ReloadShaders();
    199199
    200200protected:

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

    r27493 r27693  
    3333#include "ps/CStrInternStatic.h"
    3434#include "ps/Profile.h"
    35 #include "ps/VideoMode.h"
    3635#include "renderer/backend/IDevice.h"
    3736#include "renderer/backend/ITexture.h"
    … …  
    5857struct ShadowMapInternals
    5958{
     59
     60
    6061    std::unique_ptr<Renderer::Backend::IFramebuffer> Framebuffer;
    6162    std::unique_ptr<Renderer::Backend::ITexture> Texture;
    … …  
    125126    CFG_GET_VAL("shadowscascadecount", CascadeCount);
    126127
    127     if (CascadeCount < 1 || CascadeCount > MAX_CASCADE_COUNT || g_VideoMode.GetBackendDevice()->GetBackend() == Renderer::Backend::Backend::GL_ARB)
     128    if (CascadeCount < 1 || CascadeCount > MAX_CASCADE_COUNT || ->GetBackend() == Renderer::Backend::Backend::GL_ARB)
    128129        CascadeCount = 1;
    129130
    … …  
    184185}
    185186
    186 ShadowMap::ShadowMap()
     187ShadowMap::ShadowMap()
    187188{
    188189    m = new ShadowMapInternals;
     190
    189191    m->Framebuffer = 0;
    190192    m->Width = 0;
    … …  
    461463    lightToTex._44 = 1.0;
    462464
    463     if (g_VideoMode.GetBackendDevice()->GetBackend() == Renderer::Backend::Backend::VULKAN)
     465    if (->GetBackend() == Renderer::Backend::Backend::VULKAN)
    464466    {
    465467        CMatrix3D flip;
    … …  
    480482    Texture.reset();
    481483    DummyTexture.reset();
    482 
    483     Renderer::Backend::IDevice* backendDevice = g_VideoMode.GetBackendDevice();
    484484
    485485    CFG_GET_VAL("shadowquality", QualityLevel);
    … …  
    509509    // Clamp to the maximum texture size.
    510510    shadowMapSize = std::min(
    511         shadowMapSize, static_cast<int>(backendDevice->GetCapabilities().maxTextureSize));
     511        shadowMapSize, static_cast<int>(Device->GetCapabilities().maxTextureSize));
    512512
    513513    Width = Height = shadowMapSize;
    … …  
    530530    default:
    531531        formatName = "Default";
    532         backendFormat = backendDevice->GetPreferredDepthStencilFormat(
     532        backendFormat = Device->GetPreferredDepthStencilFormat(
    533533            Renderer::Backend::ITexture::Usage::SAMPLED |
    534534                Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT,
    … …  
    544544    if (g_RenderingOptions.GetShadowAlphaFix())
    545545    {
    546         DummyTexture = backendDevice->CreateTexture2D("ShadowMapDummy",
     546        DummyTexture = Device->CreateTexture2D("ShadowMapDummy",
    547547            Renderer::Backend::ITexture::Usage::COLOR_ATTACHMENT,
    548548            Renderer::Backend::Format::R8G8B8A8_UNORM, Width, Height,
    … …  
    567567    samplerDesc.compareOp = Renderer::Backend::CompareOp::LESS_OR_EQUAL;
    568568
    569     Texture = backendDevice->CreateTexture2D("ShadowMapDepth",
     569    Texture = Device->CreateTexture2D("ShadowMapDepth",
    570570        Renderer::Backend::ITexture::Usage::SAMPLED |
    571571            Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT,
    … …  
    588588    depthStencilAttachment.storeOp = Renderer::Backend::AttachmentStoreOp::STORE;
    589589
    590     Framebuffer = backendDevice->CreateFramebuffer("ShadowMapFramebuffer",
     590    Framebuffer = Device->CreateFramebuffer("ShadowMapFramebuffer",
    591591        useDummyTexture ? &colorAttachment : nullptr, &depthStencilAttachment);
    592592    if (!Framebuffer)

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

    r27151 r27693  
    3939{
    4040public:
    41     ShadowMap();
     41    ShadowMap();
    4242    ~ShadowMap();
    4343

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

    r27363 r27693  
    3333#include "ps/Filesystem.h"
    3434#include "ps/Game.h"
    35 #include "ps/VideoMode.h"
    3635#include "renderer/backend/IDevice.h"
    3736#include "renderer/Renderer.h"
    … …  
    122121
    123122    std::unique_ptr<Renderer::Backend::ITexture> skyCubeMap =
    124         g_VideoMode.GetBackendDevice()->CreateTexture("SkyCubeMap",
     123        Device()->CreateTexture("SkyCubeMap",
    125124            Renderer::Backend::ITexture::Type::TEXTURE_CUBE,
    126125            Renderer::Backend::ITexture::Usage::TRANSFER_DST |

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

    r27412 r27693  
    2929#include "ps/CStrInternStatic.h"
    3030#include "ps/Game.h"
    31 #include "ps/VideoMode.h"
    3231#include "ps/World.h"
    3332#include "renderer/backend/IDevice.h"
    … …  
    7069};
    7170
    72 WaterManager::WaterManager()
     71WaterManager::WaterManager(Renderer::Backend::IDevice* device)
     72    : m_Device(device)
    7373{
    7474    // water
    … …  
    215215void WaterManager::RecreateOrLoadTexturesIfNeeded()
    216216{
    217     Renderer::Backend::IDevice* backendDevice = g_VideoMode.GetBackendDevice();
    218 
    219217    // Use screen-sized textures for minimum artifacts.
    220218    const size_t newRefTextureSize = round_up_to_pow2(g_Renderer.GetHeight());
    … …  
    234232
    235233    const Renderer::Backend::Format depthFormat =
    236         backendDevice->GetPreferredDepthStencilFormat(
     234        Device->GetPreferredDepthStencilFormat(
    237235            Renderer::Backend::ITexture::Usage::SAMPLED |
    238236                Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT,
    … …  
    245243    if (needsReflectionTextures && !m_ReflectionTexture)
    246244    {
    247         m_ReflectionTexture = backendDevice->CreateTexture2D("WaterReflectionTexture",
     245        m_ReflectionTexture = Device->CreateTexture2D("WaterReflectionTexture",
    248246            Renderer::Backend::ITexture::Usage::SAMPLED |
    249247                Renderer::Backend::ITexture::Usage::COLOR_ATTACHMENT,
    … …  
    253251                Renderer::Backend::Sampler::AddressMode::MIRRORED_REPEAT));
    254252
    255         m_ReflFboDepthTexture = backendDevice->CreateTexture2D("WaterReflectionDepthTexture",
     253        m_ReflFboDepthTexture = Device->CreateTexture2D("WaterReflectionDepthTexture",
    256254            Renderer::Backend::ITexture::Usage::SAMPLED |
    257255                Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT,
    … …  
    272270        depthStencilAttachment.storeOp = Renderer::Backend::AttachmentStoreOp::STORE;
    273271
    274         m_ReflectionFramebuffer = backendDevice->CreateFramebuffer("ReflectionFramebuffer",
     272        m_ReflectionFramebuffer = Device->CreateFramebuffer("ReflectionFramebuffer",
    275273            &colorAttachment, &depthStencilAttachment);
    276274        if (!m_ReflectionFramebuffer)
    … …  
    287285    if (needsRefractionTextures && !m_RefractionTexture)
    288286    {
    289         m_RefractionTexture = backendDevice->CreateTexture2D("WaterRefractionTexture",
     287        m_RefractionTexture = Device->CreateTexture2D("WaterRefractionTexture",
    290288            Renderer::Backend::ITexture::Usage::SAMPLED |
    291289                Renderer::Backend::ITexture::Usage::COLOR_ATTACHMENT,
    … …  
    295293                Renderer::Backend::Sampler::AddressMode::MIRRORED_REPEAT));
    296294
    297         m_RefrFboDepthTexture = backendDevice->CreateTexture2D("WaterRefractionDepthTexture",
     295        m_RefrFboDepthTexture = Device->CreateTexture2D("WaterRefractionDepthTexture",
    298296            Renderer::Backend::ITexture::Usage::SAMPLED |
    299297                Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT,
    … …  
    314312        depthStencilAttachment.storeOp = Renderer::Backend::AttachmentStoreOp::STORE;
    315313
    316         m_RefractionFramebuffer = backendDevice->CreateFramebuffer("RefractionFramebuffer",
     314        m_RefractionFramebuffer = Device->CreateFramebuffer("RefractionFramebuffer",
    317315            &colorAttachment, &depthStencilAttachment);
    318316        if (!m_RefractionFramebuffer)
    … …  
    339337    if (needsFancyTextures && !m_FancyTexture)
    340338    {
    341         m_FancyTexture = backendDevice->CreateTexture2D("WaterFancyTexture",
     339        m_FancyTexture = Device->CreateTexture2D("WaterFancyTexture",
    342340            Renderer::Backend::ITexture::Usage::SAMPLED |
    343341                Renderer::Backend::ITexture::Usage::COLOR_ATTACHMENT,
    … …  
    347345                Renderer::Backend::Sampler::AddressMode::REPEAT));
    348346
    349         m_FancyTextureDepth = backendDevice->CreateTexture2D("WaterFancyDepthTexture",
     347        m_FancyTextureDepth = Device->CreateTexture2D("WaterFancyDepthTexture",
    350348            Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT,
    351349            depthFormat, g_Renderer.GetWidth(), g_Renderer.GetHeight(),
    … …  
    366364        depthStencilAttachment.storeOp = Renderer::Backend::AttachmentStoreOp::STORE;
    367365
    368         m_FancyEffectsFramebuffer = backendDevice->CreateFramebuffer("FancyEffectsFramebuffer",
     366        m_FancyEffectsFramebuffer = Device->CreateFramebuffer("FancyEffectsFramebuffer",
    369367            &colorAttachment, &depthStencilAttachment);
    370368
    … …  
    380378        occludersDepthStencilAttachment.storeOp = Renderer::Backend::AttachmentStoreOp::DONT_CARE;
    381379
    382         m_FancyEffectsOccludersFramebuffer = backendDevice->CreateFramebuffer("FancyEffectsOccludersFramebuffer",
     380        m_FancyEffectsOccludersFramebuffer = Device->CreateFramebuffer("FancyEffectsOccludersFramebuffer",
    383381            &occludersColorAttachment, &occludersDepthStencilAttachment);
    384382        if (!m_FancyEffectsFramebuffer || !m_FancyEffectsOccludersFramebuffer)
    … …  
    11301128{
    11311129    return
    1132         m_RenderWater && g_VideoMode.GetBackendDevice()->GetBackend() != Renderer::Backend::Backend::GL_ARB &&
     1130        m_RenderWater && ->GetBackend() != Renderer::Backend::Backend::GL_ARB &&
    11331131        g_RenderingOptions.GetWaterEffects();
    11341132}

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

    r27375 r27693  
    131131
    132132public:
    133     WaterManager();
     133    WaterManager();
    134134    ~WaterManager();
    135135
    … …  
    208208    size_t GetCurrentTextureIndex(const double& period) const;
    209209    size_t GetNextTextureIndex(const double& period) const;
     210
     211
     212
    210213};
    211214

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

    r27313 r27693  
    8282        LOSTexture(Simulation2),
    8383        TerritoryTexture(Simulation2),
    84         MiniMapTexture(Simulation2)
     84        MiniMapTexture(Simulation2)
    8585    {
    8686        UnitManager.SetObjectManager(ObjectManager);
Note: See TracChangeset for help on using the changeset viewer.