Renderer.h

#pragma once
 
// Standard.
#include <variant>
#include <vector>
#include <string>
#include <filesystem>
#include <memory>
 
// Custom.
#include "misc/Error.h"
#include "render/general/resource/frame/FrameResourceManager.h"
#include "render/RenderSettings.h"
#include "game/camera/CameraProperties.h"
#include "render/RenderStatistics.h"
#include "render/general/resource/MeshData.h"
#include "shader/ComputeShaderInterface.h"
 
namespace ne {
    class GameManager;
    class Window;
    class PipelineManager;
    class RenderSettings;
    class EnvironmentNode;
    class MeshNode;
    class Material;
    class Pipeline;
    class ShadowMapHandle;
    class DirectionalLightNode;
    class SpotlightNode;
    class PointLightNode;
    class GpuResourceManager;
    class LightingShaderResourceManager;
    class ShaderCpuWriteResourceBindingManager;
    class ShaderTextureResourceBindingManager;
    class ShaderLightArray;
    class ShaderManager;
    class GlobalShaderResourceBindingManager;
    struct ShaderLightsInFrustumSingleType;
    struct GraphicsPipelineRegistry;
 
    class Renderer {
        // Only window should be able to request new frames to be drawn.
        friend class Window;
 
        // Settings will modify renderer's state.
        friend class RenderSettings;
 
        // This node sets itself to the renderer when spawned so that its parameters will be used
        // in the rendering (also removes itself when despawned).
        friend class EnvironmentNode;
 
        // Notifies when active camera changes.
        friend class CameraManager;
 
    public:
        Renderer() = delete;
        Renderer(const Renderer&) = delete;
        Renderer& operator=(const Renderer&) = delete;
 
        virtual ~Renderer();
 
        static constexpr float getMinDepth() { return minDepth; }
 
        static constexpr float getMaxDepth() { return maxDepth; }
 
        static std::variant<std::unique_ptr<Renderer>, Error>
        create(GameManager* pGameManager, std::optional<RendererType> preferredRenderer);
 
        virtual std::vector<std::string> getSupportedGpuNames() const = 0;
 
        virtual std::variant<std::set<std::pair<unsigned int, unsigned int>>, Error>
        getSupportedRenderResolutions() const = 0;
 
        virtual std::variant<std::set<std::pair<unsigned int, unsigned int>>, Error>
        getSupportedRefreshRates() const = 0;
 
        virtual RendererType getType() const = 0;
 
        virtual std::string getUsedApiVersion() const = 0;
 
        std::pair<std::recursive_mutex*, RenderSettings*> getRenderSettings();
 
        RenderStatistics* getRenderStatistics();
 
        virtual std::string getCurrentlyUsedGpuName() const = 0;
 
        size_t getTotalVideoMemoryInMb() const;
 
        size_t getUsedVideoMemoryInMb() const;
 
        virtual void waitForGpuToFinishWorkUpToThisPoint() = 0;
 
        virtual std::pair<unsigned int, unsigned int> getRenderTargetSize() const = 0;
 
        Window* getWindow() const;
 
        GameManager* getGameManager() const;
 
        ShaderManager* getShaderManager() const;
 
        PipelineManager* getPipelineManager() const;
 
        GpuResourceManager* getResourceManager() const;
 
        FrameResourceManager* getFrameResourceManager() const;
 
        ShaderCpuWriteResourceBindingManager* getShaderCpuWriteResourceManager() const;
 
        ShaderTextureResourceBindingManager* getShaderTextureResourceManager() const;
 
        LightingShaderResourceManager* getLightingShaderResourceManager() const;
 
        GlobalShaderResourceBindingManager* getGlobalShaderResourceBindingManager() const;
 
        std::recursive_mutex* getRenderResourcesMutex();
 
        virtual GpuResource* getDepthTextureNoMultisampling() = 0;
 
    protected:
        struct MeshesInFrustum {
            struct MeshInFrustumInfo {
                MeshNode* pMeshNode = nullptr;
 
                std::vector<MeshIndexBufferInfo> vIndexBuffers;
            };
 
            struct MaterialInFrustumInfo {
                Material* pMaterial = nullptr;
 
                std::vector<MeshInFrustumInfo> vMeshes;
            };
 
            struct PipelineInFrustumInfo {
                Pipeline* pPipeline = nullptr;
 
                std::vector<MaterialInFrustumInfo> vMaterials;
            };
 
            std::vector<PipelineInFrustumInfo> vOpaquePipelines;
 
            std::vector<PipelineInFrustumInfo> vTransparentPipelines;
        };
 
        struct LightsInFrustum {
            std::pair<std::recursive_mutex*, ShaderLightsInFrustumSingleType*> mtxPointLightsInFrustum;
 
            std::pair<std::recursive_mutex*, ShaderLightsInFrustumSingleType*> mtxSpotlightsInFrustum;
 
            // No directional lights here because directional lights can't be culled.
        };
 
        static consteval unsigned int getRecommendedSwapChainBufferCount() {
            return iRecommendedSwapChainBufferCount;
        }
 
        static void getDirectionalLightNodeShadowMappingInfo(
            DirectionalLightNode* pNode,
            ShadowMapHandle*& pShadowMapHandle,
            unsigned int& iShadowPassLightInfoArrayIndex);
 
        static void getSpotlightNodeShadowMappingInfo(
            SpotlightNode* pNode,
            ShadowMapHandle*& pShadowMapHandle,
            unsigned int& iShadowPassLightInfoArrayIndex);
 
        static unsigned int
        getPointLightShadowPassLightInfoArrayIndex(PointLightNode* pNode, size_t iCubemapFaceIndex);
 
        static ShadowMapHandle* getPointLightNodeShadowMapHandle(PointLightNode* pNode);
 
        Renderer(GameManager* pGameManager);
 
        [[nodiscard]] std::optional<Error> compileEngineShaders() const;
 
        void
        updateFrameConstantsBuffer(FrameResource* pCurrentFrameResource, CameraProperties* pCameraProperties);
 
        void resetGpuResourceManager();
 
        void resetPipelineManager();
 
        void resetFrameResourceManager();
 
        void resetLightingShaderResourceManager();
 
        virtual std::variant<std::optional<AntialiasingQuality>, Error>
        getMaxSupportedAntialiasingQuality() const = 0;
 
        void onFramebufferSizeChanged(int iWidth, int iHeight);
 
        virtual void onFramebufferSizeChangedDerived(int iWidth, int iHeight) {}
 
        void drawNextFrame();
 
        virtual void prepareRenderTargetForNextFrame() {}
 
        virtual void prepareForDrawingNextFrame(
            CameraProperties* pCameraProperties, FrameResource* pCurrentFrameResource) = 0;
 
        virtual void drawShadowMappingPass(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            GraphicsPipelineRegistry* pGraphicsPipelines) = 0;
 
        virtual void drawMeshesDepthPrepass(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& vOpaquePipelines) = 0;
 
        virtual void executeComputeShadersOnGraphicsQueue(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            ComputeExecutionStage stage) = 0;
 
        virtual void drawMeshesMainPass(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& vOpaquePipelines,
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& vTransparentPipelines) = 0;
 
        virtual void present(FrameResource* pCurrentFrameResource, size_t iCurrentFrameResourceIndex) = 0;
 
        [[nodiscard]] std::optional<Error> onRenderSettingsChanged(bool bShadowMapSizeChanged = false);
 
        [[nodiscard]] virtual std::optional<Error> onRenderSettingsChangedDerived() = 0;
 
        virtual void waitForGpuToFinishUsingFrameResource(FrameResource* pFrameResource) = 0;
 
        virtual bool isInitialized() const = 0;
 
        [[nodiscard]] std::optional<Error> initializeRenderer();
 
        [[nodiscard]] std::optional<Error> initializeResourceManagers();
 
        [[nodiscard]] std::optional<Error> clampSettingsToMaxSupported();
 
        [[nodiscard]] std::optional<Error> recalculateLightTileFrustums();
 
        MeshesInFrustum* getMeshesInCameraFrustum(
            CameraProperties* pActiveCameraProperties, GraphicsPipelineRegistry* pGraphicsPipelines);
 
        void cullLightsOutsideCameraFrustum(
            CameraProperties* pActiveCameraProperties, size_t iCurrentFrameResourceIndex);
 
        inline std::pair<std::mutex, FrameConstants>* getFrameConstants() { return &mtxFrameConstants; }
 
        inline std::atomic<size_t>* getDrawCallCounter() {
            return &renderStats.frameTemporaryStatistics.iDrawCallCount;
        }
 
    private:
        static std::unique_ptr<Renderer>
        createRenderer(GameManager* pGameManager, std::optional<RendererType> preferredRenderer);
 
        static std::variant<std::unique_ptr<Renderer>, std::pair<Error, std::string>> createRenderer(
            RendererType type,
            GameManager* pGameManager,
            const std::vector<std::string>& vBlacklistedGpuNames);
 
#if defined(WIN32)
        static void nanosleep(long long iNanoseconds);
#endif
        void calculateFrameStatistics();
 
        void updateResourcesForNextFrame(
            unsigned int iRenderTargetWidth,
            unsigned int iRenderTargetHeight,
            CameraProperties* pCameraProperties);
 
        void onActiveCameraChanged();
 
        void recalculateTargetFrameTimeFromFpsLimitSetting();
 
        void setupRenderStats();
 
        std::optional<Error> initializeRenderSettings();
 
        std::recursive_mutex mtxRwRenderResources;
 
        std::unique_ptr<GpuResourceManager> pResourceManager;
 
        std::unique_ptr<ShaderManager> pShaderManager;
 
        std::unique_ptr<PipelineManager> pPipelineManager;
 
        std::unique_ptr<FrameResourceManager> pFrameResourceManager;
 
        std::unique_ptr<ShaderCpuWriteResourceBindingManager> pShaderCpuWriteResourceManager;
 
        std::unique_ptr<ShaderTextureResourceBindingManager> pShaderTextureResourceManager;
 
        std::unique_ptr<LightingShaderResourceManager> pLightingShaderResourceManager;
 
        std::unique_ptr<GlobalShaderResourceBindingManager> pGlobalShaderResourceBindingManager;
 
        std::pair<std::recursive_mutex, std::unique_ptr<RenderSettings>> mtxRenderSettings;
 
        MeshesInFrustum meshesInFrustumLastFrame;
 
        bool bIsWindowMinimized = false;
 
        std::pair<std::mutex, EnvironmentNode*> mtxSpawnedEnvironmentNode;
 
        std::pair<std::mutex, FrameConstants> mtxFrameConstants;
 
        RenderStatistics renderStats;
 
        GameManager* pGameManager = nullptr;
 
        static constexpr unsigned int iRecommendedSwapChainBufferCount = 2;
 
        static constexpr float minDepth = 0.0F;
 
        static constexpr float maxDepth = 1.0F;
    };
} // namespace ne