Renderer.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
#include "Resources/Forward.hpp"
 
#include "RendererCamera.hpp"
#include "RendererLight.hpp"
#include "RendererRenderable.hpp"
#include "RendererScene.hpp"
#include "RendererSettings.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Threading/ExecutionContext.hpp"
 
#include "CeresEngine/Scene/Camera.hpp"
#include "CeresEngine/Scene/Environment.hpp"
#include "CeresEngine/Scene/Light.hpp"
#include "CeresEngine/Scene/Renderable.hpp"
#include "CeresEngine/Scene/Scene.hpp"
 
#include "CeresEngine/Scene/Terrain/TerrainRenderable.hpp"
 
namespace CeresEngine {
 
    class Renderer {
    private: // Dependencies
        GPUDevice& mDevice;
 
        ResourceManager& mResourceManager;
 
    private: // Managers
        UPtr<RendererMeshManager> mMeshManager;
 
        UPtr<RendererTextureManager> mTextureManager;
 
        UPtr<RendererShaderManager> mShaderManager;
 
        UPtr<RendererGraphicsPipelineManager> mGraphicsPipelineManager;
 
        UPtr<RendererComputePipelineManager> mComputePipelineManager;
 
        UPtr<RendererMaterialManager> mMaterialManager;
 
        UPtr<RendererSceneManager> mSceneManager;
 
        UPtr<RendererCameraManager> mCameraManager;
 
        UPtr<RendererLightManager> mLightManager;
 
        UPtr<RendererRenderableManager> mRenderableManager;
 
        UPtr<RendererTerrainManager> mTerrainManager;
 
        UPtr<RendererEnvironmentManager> mEnvironmentManager;
 
        UPtr<ShadowRenderer> mShadowRenderer;
 
    private: // State
        RendererSettings mSettings;
 
        HashMap<UInt64, RendererShaderPtr> mShaders;
 
    private: // Cache & bultin resources.
        GPUImagePtr mNullCubeTexture;
 
        GPUImagePtr mNullTexture;
 
        GPUImagePtr mBRDF;
 
        GPUPipelineLayoutPtr mBindlessPipelineLayout;
 
    public:
        explicit Renderer(GPUDevice& device, ResourceManager& resourceManager);
 
        ~Renderer();
 
    public:
        void render();
 
        void render(const RendererView& view);
 
    public:
        SPtr<RendererMaterial> findMaterial(const HMaterial& material);
 
        [[nodiscard]] RendererShaderPtr getShader(StringView name);
 
        [[nodiscard]] RendererShaderPtr getOldShader(StringView name);
 
    public:
        RendererScene& createScene();
 
    public:
        [[nodiscard]] GPUDevice& getDevice() const noexcept { return mDevice; }
 
        [[nodiscard]] ResourceManager& getResourceManager() const noexcept { return mResourceManager; }
 
        [[nodiscard]] const RendererSettings& getSettings() const noexcept { return mSettings; }
 
        void setSettings(const RendererSettings& rendererSettings);
 
    public: // Managers
        [[nodiscard]] RendererSceneManager& getSceneManager() const noexcept { return *mSceneManager; }
 
        [[nodiscard]] RendererCameraManager& getCameraManager() const noexcept { return *mCameraManager; }
 
        [[nodiscard]] RendererLightManager& getLightManager() const noexcept { return *mLightManager; }
 
        [[nodiscard]] RendererRenderableManager& getRenderableManager() const noexcept { return *mRenderableManager; }
 
        [[nodiscard]] RendererTerrainManager& getTerrainManager() const noexcept { return *mTerrainManager; }
 
        [[nodiscard]] RendererEnvironmentManager& getEnvironmentManager() const noexcept { return *mEnvironmentManager; }
 
        [[nodiscard]] RendererMeshManager& getMeshManager() const noexcept { return *mMeshManager; }
 
        [[nodiscard]] RendererTextureManager& getTextureManager() const noexcept { return *mTextureManager; }
 
        [[nodiscard]] RendererMaterialManager& getMaterialManager() const noexcept { return *mMaterialManager; }
 
        [[nodiscard]] RendererShaderManager& getShaderManager() const noexcept { return *mShaderManager; }
 
        [[nodiscard]] RendererGraphicsPipelineManager& getGraphicsPipelineManager() const noexcept { return *mGraphicsPipelineManager; }
 
        [[nodiscard]] RendererComputePipelineManager& getComputePipelineManager() const noexcept { return *mComputePipelineManager; }
 
        [[nodiscard]] ShadowRenderer& getShadowRenderer() const noexcept { return *mShadowRenderer; }
 
    public:
        [[nodiscard]] Matrix4 getClipMatrix() const;
 
        [[nodiscard]] const GPUImagePtr& getNullTexture() const { return mNullTexture; }
 
        [[nodiscard]] const GPUImagePtr& getNullCubeTexture() const { return mNullCubeTexture; }
 
        [[nodiscard]] const GPUImagePtr& getBRDF() const { return mBRDF; }
 
        [[nodiscard]] const GPUPipelineLayoutPtr& getBindlessPipelineLayout() const noexcept { return mBindlessPipelineLayout; }
 
        [[nodiscard]] RendererMaterial& getDefaultMaterial() const;
 
        [[nodiscard]] bool isBindlessSupported() const noexcept { return true; }
 
        [[nodiscard]] RendererShaderPtr getBasePass();
 
    private:
        [[nodiscard]] GPUImagePtr generateBRDF(GPUCommandBuffer& commandBuffer);
    };
 
    struct RendererContext {
        GPUDevice& device;
 
        GPUCommandBuffer& commandBuffer;
 
        GPUUniformBufferPool uniforms;
 
        GPUStorageBufferPool storage;
 
        AnyExecutor executor;
 
        explicit RendererContext(GPUCommandBuffer& commandBuffer, AnyExecutor executor);
    };
 
} // namespace CeresEngine