Renderer.h

#pragma once
 
// Standard.
#include <variant>
#include <vector>
#include <string>
#include <filesystem>
#include <memory>
 
// Custom.
#include "shader/general/resources/cpuwrite/ShaderCpuWriteResourceManager.h"
#include "shader/general/resources/texture/ShaderTextureResourceManager.h"
#include "misc/Error.h"
#include "shader/ShaderManager.h"
#include "render/general/resources/GpuResourceManager.h"
#include "render/general/resources/frame/FrameResourcesManager.h"
#include "render/RenderSettings.h"
#include "game/camera/CameraProperties.h"
#include "shader/general/resources/LightingShaderResourceManager.h"
#include "material/Material.h"
#include "render/RenderStatistics.h"
 
namespace ne {
    class GameManager;
    class Window;
    class PipelineManager;
    class ShaderConfiguration;
    class RenderSettings;
    class EnvironmentNode;
    class MeshNode;
    class Material;
    class Pipeline;
    class ShadowMapHandle;
    class DirectionalLightNode;
    class SpotlightNode;
    class PointLightNode;
 
    class Renderer {
        // Only window should be able to request new frames to be drawn.
        friend class Window;
 
        // Can update shader configuration.
        friend class ShaderConfiguration;
 
        // 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() = default;
 
        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;
 
        std::pair<std::recursive_mutex, std::unique_ptr<ShaderConfiguration>>* getShaderConfiguration();
 
        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;
 
        FrameResourcesManager* getFrameResourcesManager() const;
 
        ShaderCpuWriteResourceManager* getShaderCpuWriteResourceManager() const;
 
        ShaderTextureResourceManager* getShaderTextureResourceManager() const;
 
        LightingShaderResourceManager* getLightingShaderResourceManager() 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*, ShaderLightArray::LightsInFrustum*> mtxPointLightsInFrustum;
 
            std::pair<std::recursive_mutex*, ShaderLightArray::LightsInFrustum*> 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 resetFrameResourcesManager();
 
        void resetLightingShaderResourceManager();
 
        virtual std::variant<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,
            PipelineManager::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,
            PipelineManager::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 updateTargetTimeToRenderFrame();
 
        void updateShaderConfiguration();
 
        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<FrameResourcesManager> pFrameResourcesManager;
 
        std::unique_ptr<ShaderCpuWriteResourceManager> pShaderCpuWriteResourceManager;
 
        std::unique_ptr<ShaderTextureResourceManager> pShaderTextureResourceManager;
 
        std::unique_ptr<LightingShaderResourceManager> pLightingShaderResourceManager;
 
        std::pair<std::recursive_mutex, std::unique_ptr<ShaderConfiguration>> mtxShaderConfiguration;
 
        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;
    };
 
    class ShaderConfiguration {
    public:
        ShaderConfiguration() = delete;
 
        ShaderConfiguration(Renderer* pRenderer) { this->pRenderer = pRenderer; }
 
        void updateShaderConfiguration() { pRenderer->updateShaderConfiguration(); }
 
        std::set<ShaderMacro> currentVertexShaderConfiguration;
 
        std::set<ShaderMacro> currentPixelShaderConfiguration;
 
    private:
        Renderer* pRenderer = nullptr;
    };
} // namespace ne