Renderer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "components/GameComponents/BasicComponents.hpp"
#include "context.hpp"
#include "Resources.hpp"
#include "Pipeline.hpp"
#include "SwapchainManager.hpp"
#include "VulkanImGUIWrapper.hpp"
#include "VulkanMesh.hpp"
#include "components/UI/VexUI.hpp"
#include "MeshManager.hpp"
#include "PhysicsDebug.hpp"
 
#include <glm/glm.hpp>
#include <chrono>
#include <components/GameComponents/UiComponent.hpp>
#include "components/GameComponents/BillboardComponent.hpp"
#include "components/GameComponents/ParticleEmitterComponent.hpp"
 
namespace vex {
    struct RenderItem {
        vex::Entity entity;
        uint32_t modelIndex;
    };

    struct BillboardItem {
        vex::Entity entity;
        uint32_t texID;
    };
 
    struct EditorBillboardItem {
        vex::Entity entity;
        uint32_t texID;
        float offsetX;
    };

    struct BillboardPushData {
        glm::vec3 pos;    
        float sx;         
        float sy;         
        uint32_t tID;     
        uint32_t unlit;   
        float pad;        
        glm::vec4 col;    
    };

        struct SceneRenderData {
            VkCommandBuffer commandBuffer;
            uint32_t frameIndex;
            uint32_t imageIndex;
            VkDescriptorSet imguiTextureID;
            bool isSwapchainValid;
        };

    class Renderer {
    public:
        Renderer(VulkanContext& context,
                 std::unique_ptr<VulkanResources>& resources,
                 std::unique_ptr<VulkanPipeline>& pipeline,
                 std::unique_ptr<VulkanPipeline>& transPipeline,
                 std::unique_ptr<VulkanPipeline>& maskPipeline,
                 std::unique_ptr<VulkanPipeline>& billboardTransPipeline,
                 std::unique_ptr<VulkanPipeline>& billboardMaskedPipeline,
                 std::unique_ptr<VulkanPipeline>& particleTransPipeline,
                 std::unique_ptr<VulkanPipeline>& particleMaskedPipeline,
                 std::unique_ptr<VulkanPipeline>& uiPipeline,
                 std::unique_ptr<VulkanPipeline>& fullscreenPipeline,
                 std::unique_ptr<VulkanPipeline>& compositePipeline,
                 std::unique_ptr<VulkanSwapchainManager>& swapchainManager,
                 std::unique_ptr<MeshManager>& meshManager);

        ~Renderer();

        bool beginFrame(glm::uvec2 renderResolution, SceneRenderData& outData);

        void renderScene(SceneRenderData& data,
                         const vex::Entity cameraEntity,
                         vex::Registry& registry,
                         int frame,
                         const std::vector<DebugVertex>* debugLines = nullptr,
                         bool isEditorMode = false);

        VkDescriptorSet getImGuiTextureID(ImGUIWrapper& ui);

        void composeFrame(SceneRenderData& data,
                          ImGUIWrapper& ui,
                          bool isEditorMode);

        void endFrame(SceneRenderData& data);
 
        #if DEBUG
            void setDebugPipeline(std::unique_ptr<VulkanPipeline>* pipeline) { m_pp_debugPipeline = pipeline; }

            void renderDebug(VkCommandBuffer cmd, int frameIndex, const std::vector<DebugVertex>& lines);
        #endif
 
    private:
        void transitionImageLayout(VkCommandBuffer cmd, VkImage image,
                                   VkImageLayout oldLayout, VkImageLayout newLayout,
                                   VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask,
                                   VkPipelineStageFlags srcStage, VkPipelineStageFlags dstStage);

        void issueMultiDrawIndexed(VkCommandBuffer cmd, const std::vector<VkMultiDrawIndexedInfoEXT>& commands);

        void updateScreenDescriptor(VkImageView view);
 
        VulkanContext& m_r_context;
        std::unique_ptr<VulkanResources>& m_p_resources;
        std::unique_ptr<VulkanPipeline>& m_p_pipeline;
        std::unique_ptr<VulkanPipeline>& m_p_transPipeline; 
        std::unique_ptr<VulkanPipeline>& m_p_maskPipeline; 
        std::unique_ptr<VulkanPipeline>& m_p_billboardTransPipeline; 
        std::unique_ptr<VulkanPipeline>& m_p_billboardMaskedPipeline; 
        std::unique_ptr<VulkanPipeline>& m_p_particleTransPipeline; 
        std::unique_ptr<VulkanPipeline>& m_p_particleMaskedPipeline; 
        std::unique_ptr<VulkanPipeline>& m_p_uiPipeline;
        std::unique_ptr<VulkanPipeline>& m_p_fullscreenPipeline;
        std::unique_ptr<VulkanPipeline>& m_p_compositePipeline;
        std::unique_ptr<VulkanSwapchainManager>& m_p_swapchainManager;
        std::unique_ptr<MeshManager>& m_p_meshManager;
 
        std::chrono::high_resolution_clock::time_point startTime;
        float currentTime = 0.0f;
 
        bool basicDiag = true;
 
        std::vector<TransparentTriangle> m_transparentTriangles;
        std::map<uint32_t, glm::mat4> trnasMatrixes;
        std::vector<UiComponent> m_uiObjects;
        std::vector<VkMultiDrawIndexedInfoEXT> m_multiDrawInfos;
        size_t approxTriangles = 0;
 
        SceneUBO m_sceneUBO;
 
        VkDescriptorSet m_screenDescriptorSet = VK_NULL_HANDLE;
        VkDescriptorSet m_crtDescriptorSet = VK_NULL_HANDLE;
        VkSampler m_screenSampler = VK_NULL_HANDLE;
        VkSampler m_linearSampler = VK_NULL_HANDLE;
        VkImageView m_lastUsedView = VK_NULL_HANDLE;
        VkDescriptorSet m_cachedImGuiDescriptor = VK_NULL_HANDLE;
        std::vector<std::vector<VkDescriptorSet>> m_garbageDescriptors;
        VkDescriptorPool m_localPool = VK_NULL_HANDLE;
 
        std::vector<RenderItem> opaqueQueue;      
        std::vector<RenderItem> maskedQueue;      
        std::vector<RenderItem> transparentQueue; 
        std::vector<BillboardItem> bMaskedQueue;  
        std::vector<BillboardItem> bTransQueue;   
        std::vector<EditorBillboardItem> bEditorQueue;  
        std::vector<vex::Entity> pMaskedQueue;   
        std::vector<vex::Entity> pTransQueue;    
 
        std::vector<VkBuffer> m_indirectBuffers;
        std::vector<VmaAllocation> m_indirectAllocations;
 
        #if DEBUG
            std::vector<VkBuffer> m_debugBuffers;
            std::vector<VmaAllocation> m_debugAllocations;
            std::unique_ptr<VulkanPipeline>* m_pp_debugPipeline = nullptr;
            std::unique_ptr<VulkanMesh> m_editorCameraVulkanMesh;
            MeshData m_editorCameraMesh;
        #endif
    };
}