Renderer.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** Renderer
*/
 
#pragma once
 
#include "evan/ADeviceBackend.hpp"
#include "evan/DeviceContext.hpp"
#include "evan/ASwapchainContext.hpp"
 
#include "evan/Frame.hpp"
 
#include "evan/FrameStats.hpp"
 
#include "evan/RenderSettings.hpp"
#include "evan/RessourceManager.hpp"
 
#include "evan/GPUShader.hpp"
#include "evan/GPUVertex.hpp"
#include "evan/GPUMesh.hpp"
 
#include "evan/RenderObject.hpp"
 
#include <utility/graphic/scissor.hpp>
#include <utility/graphic/view.hpp>
 
#include <utility/logging/loggable.hpp>
#include <utility/logging/default_logger.hpp>
 
#include <fstream>
#include <algorithm>
#include <map>
#include <memory>
#include <optional>
#include <cstdint>
#include <map>
#include <span>
#include <vector>
 
namespace evan
{
    class Renderer:
        protected utility::logging::Loggable<Renderer,
                                             utility::logging::DefaultLogger>
    {
        public:
        Renderer(std::shared_ptr<DeviceContext> deviceContext,
                 VkRenderPass renderPass, VkSampleCountFlagBits msaaSamples,
                 std::size_t perFrameSlotCount,
                 std::shared_ptr<RessourceManager> ressourceManager);
 
        ~Renderer();
 
        void destroy(VkDevice device);
 
        size_t addObject(std::shared_ptr<RenderObject> object);
 
        bool updateObject(std::shared_ptr<RenderObject> object,
                          size_t objectID);
 
        bool removeObject(size_t objectID);
 
        std::shared_ptr<RenderObject> getObject(size_t objectID) const;
 
        Error drawFrame(const DeviceContext &deviceContext,
                        ASwapchainContext &swapchainContext);
 
        void setScissor(const utility::graphic::ScissorRect &rect);
 
        void clearScissor(void);
 
        [[nodiscard]] static VkRect2D
            clampScissor(const utility::graphic::ScissorRect &rect,
                         VkExtent2D extent);
 
        [[nodiscard]] static bool
            viewOwnsInFlightFence(std::size_t viewIndex,
                                  std::size_t viewCount) noexcept;
 
        [[nodiscard]] const FrameStats &getStats() const noexcept
        {
            return _stats;
        }
 
        void resetStats() noexcept
        {
            _stats.resetWindow();
        }
 
        VkDescriptorPool getDescriptorPool() const;
 
        const std::vector<VkBuffer> getUniformBuffers() const;
 
        VkDescriptorSetLayout getDescriptorSetLayout() const;
 
        void setCullingEnabled(bool enabled)
        {
            _cullingEnabled = enabled;
        }
 
        [[nodiscard]] bool isCullingEnabled() const
        {
            return _cullingEnabled;
        }
 
        void setMaxDrawDistance(float maxDistance)
        {
            _maxDrawDistance = maxDistance;
        }
 
        [[nodiscard]] float getMaxDrawDistance() const
        {
            return _maxDrawDistance;
        }
 
        void setInstancingEnabled(bool enabled)
        {
            _mergeIdenticalRuns = enabled;
        }
 
        [[nodiscard]] bool isInstancingEnabled() const
        {
            return _mergeIdenticalRuns;
        }
 
        void setIndirectDrawingEnabled(bool enabled)
        {
            _indirectDrawingEnabled = enabled;
        }
 
        [[nodiscard]] bool isIndirectDrawingEnabled() const
        {
            return _indirectDrawingEnabled;
        }
 
        struct PipelineVariant {
            uint32_t shaderID   = 0;
            BlendMode blendMode = BlendMode::Opaque;
 
            bool operator<(const PipelineVariant &other) const
            {
                if (shaderID != other.shaderID) {
                    return shaderID < other.shaderID;
                }
                return static_cast<int>(blendMode)
                    < static_cast<int>(other.blendMode);
            }
        };
 
        void setShaderBlendMode(uint32_t shaderID, BlendMode blendMode);
 
        [[nodiscard]] BlendMode getShaderBlendMode(uint32_t shaderID) const;
 
        void setOpaqueSortMode(OpaqueSortMode mode)
        {
            _opaqueSortMode = mode;
        }
 
        [[nodiscard]] OpaqueSortMode getOpaqueSortMode() const
        {
            return _opaqueSortMode;
        }
 
        protected:
        std::map<PipelineVariant, VkPipeline>
            _pipelines;    
 
        std::map<uint32_t, VkPipelineLayout>
            _pipelineLayouts;    
 
        std::vector<std::shared_ptr<Frame>> _frames;
 
        std::shared_ptr<DeviceContext> _deviceContext;
 
        uint32_t _currentFrameIndex;
 
        FrameStats _stats;
 
        float _timestampPeriod = 0.0f;
 
        uint32_t _timestampValidBits = 0;
 
        VkDescriptorSetLayout _descriptorSetLayout;
 
        VkDescriptorPool _descriptorPool;
 
        std::map<size_t, std::shared_ptr<RenderObject>> _objects;
 
        size_t _nextObjectID = 1;
 
        std::optional<utility::graphic::ScissorRect> _scissor;
 
        private:
        void updateUniformBuffer(const utility::graphic::ViewF &view,
                                 std::size_t viewSlot);
 
        void updateMultiviewUniformBuffer(
            const std::vector<utility::graphic::ViewF> &views,
            std::size_t viewSlot);
 
        void recordCommandBuffer(
            VkRenderPass renderPass, VkFramebuffer swapChainFramebuffer,
            VkExtent2D swapChainExtent, std::size_t viewSlot,
            std::span<const utility::graphic::ViewF> views);
 
        void reportStatsIfDue();
 
        void readGpuTimestamps(const Frame &frame);
 
        VkPipeline pipelineFor(uint32_t shaderID, BlendMode blendMode) const;
 
        void createDescriptorSetLayout(VkDevice device);
 
        void createGraphicsPipelines(VkDevice device, VkRenderPass renderPass,
                                     VkSampleCountFlagBits msaaSamples);
 
        void createDescriptorPool(VkDevice device, uint32_t materialCount);
 
        std::vector<std::shared_ptr<GPUMesh>> getMeshes() const;
 
        std::shared_ptr<RessourceManager>
            _ressourceManager;    
 
        bool _cullingEnabled = true;
 
        float _maxDrawDistance = 0.0f;
 
        bool _mergeIdenticalRuns = false;
 
        bool _indirectDrawingEnabled = false;
 
        std::map<uint32_t, BlendMode> _shaderBlendModes;
 
        OpaqueSortMode _opaqueSortMode = OpaqueSortMode::FrontToBack;
    };
}    // namespace evan