VulkanRenderer.hpp

Go to the documentation of this file.

#pragma once
#include "Engine/Utility/Defines.hpp"
#ifdef USING_VULKAN
#include "Engine/Renderer/Renderer.hpp"
#include "Engine/Window/VulkanWindow.hpp"
#include "Engine/Renderer/IMGUI/imgui.h"
#include "Engine/Renderer/Vulkan/VulkanInstance.hpp"
#include "Engine/Renderer/Vulkan/VulkanPhysicalDevice.hpp"
#include "Engine/Renderer/Vulkan/VulkanLogicalDevice.hpp"
#include "Engine/Renderer/Vulkan/VulkanDescriptorPool.hpp"
#include "Engine/Renderer/Vulkan/VulkanPipeline.hpp"

#include "Engine/Renderer/Vulkan/VulkanSpriteRenderer.hpp"
#include "Engine/Renderer/Vulkan/VulkanDebugRenderer.hpp"
#include "Engine/Renderer/Vulkan/VulkanStaticMeshRenderer.hpp"
#include "Engine/Renderer/Vulkan/VulkanSkeletalMeshRenderer.hpp"

#include "Engine/Texture/Texture.hpp"
#include "Engine/Utility/Vertex.hpp"
#include "Engine/Renderer/Vulkan/vk_mem_alloc.h"
#include "Engine/Renderer/imgui_impl_glfw_vulkan.h"

#include "Engine/Utility/Light.hpp"

// Written by Koen Buitenhuis

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE

#include <ThirdParty/glm/glm/glm.hpp>
#include <ThirdParty/glm/glm/gtc/matrix_transform.hpp>
#include <iostream>
#include <future>
#include <thread>
#include <ThirdParty/EASTL-master/include/EASTL/string.h>
#include <ThirdParty/EASTL-master/include/EASTL/array.h>
#include <ThirdParty/EASTL-master/include/EASTL/vector.h>
#include <ThirdParty/EASTL-master/include/EASTL/memory.h>
#include <ThirdParty/EASTL-master/include/EASTL/chrono.h>


namespace Engine
{

#ifdef NDEBUG
    const bool enableValidationLayers = false;
#else
    const bool enableValidationLayers = true;
#endif

    class ENGINE_API VulkanRenderer : public Renderer {
    private:

        friend VulkanPipeline;
        friend class Engine;

        VulkanRenderer() noexcept;
        VulkanRenderer(VulkanRenderer const &other) = default;
        VulkanRenderer(VulkanRenderer &&other) noexcept = default;
    public:
        ~VulkanRenderer();
    private:

    public:
        void InitializeRenderer();

        void InitializeRenderer(eastl::weak_ptr<VulkanWindow> window);

        void Resized();

        void setClearColor(glm::vec4 color);

        VkRenderPass GetRenderPass() const;

        VkRenderPass GetGBufferRenderPass() const;

        VmaAllocator GetVmaAllocator() const;

        VkCommandPool GetGraphicsCommandPool() const;

        VkCommandPool GetComputeCommandPool() const;

        VkExtent2D GetSwapChainExtent() const;

        //Should probably add the Shader reference for vertex and fragment to this, so they can be sent to the GPU
        //Possibly also want to add an Entity reference, so you could send it's data (mesh and texture) to the GPU as well.
        //At least that's how it worked in OpenGL
        virtual void RendererBegin();
        virtual void RendererBegin(const glm::mat4x4& view, const glm::mat4x4& projection);

        //Used to render the selected Shader & Entity combination defined in RendererBegin()
        virtual void Render();

        virtual void Render(const glm::mat4x4& modelMatrix, eastl::shared_ptr<Model> model, const glm::vec4& mainColor = glm::vec4(1.f, 1.f, 1.f, 1.f));

        virtual void RenderSprite(eastl::weak_ptr<Texture> texture, glm::mat4 modelMatrix);

        virtual void RenderLine(glm::vec3 start, glm::vec3 end, glm::vec4 color = glm::vec4(1.f, 1.f, 1.f, 1.f));

        //Used to unbind the current selected Shader & Entity combination defined in RendererBegin()
        virtual void RendererEnd();

        void StartSecondaryCommandBufferRecording(VkCommandBuffer buffer, VkCommandBufferUsageFlags flags, VkRenderPass renderPass, uint32_t subPass, VkFramebuffer framebuffer) const;

        void EndSecondaryCommandBufferRecording(VkCommandBuffer buffer) const;

        enum class GBufferSubPasses {
            G_BUFFER_PASS = 0,
            SUBPASS_COUNT
        };

        enum class SsaoSubPasses {
            SSAO_PASS = 0,
            SUBPASS_COUNT
        };

        enum class RenderSubPasses {
            SSAO_BLUR_PASS = 0,
            RENDER_PASS,
            IMGUI_PASS,
            COMPOSITE_PASS,
            SUBPASS_COUNT
        };

        void CreateLight(eastl::string name, LightType lightType,
            glm::vec3 position, glm::vec3 direction, glm::vec3 color,
            float radius, float attunuation, float coneInnerAngle, float coneOuterAngle);

        void SetLightType(eastl::string name, LightType lightType);

        LightType GetLightType(eastl::string name);

        void SetLightPosition(eastl::string name, glm::vec3 position);

        glm::vec3 GetLightPosition(eastl::string name);

        void SetLightDirection(eastl::string name, glm::vec3 direction);

        glm::vec3 GetLightDirection(eastl::string name);

        void SetLightColor(eastl::string name, glm::vec3 color);

        glm::vec3 GetLightColor(eastl::string name);

        void SetLightRadius(eastl::string name, float radius);

        float GetLightRadius(eastl::string name);

        void SetLightConeInnerAngle(eastl::string name, float angle);

        float GetLightConeInnerAngle(eastl::string name);

        void SetLightConeOuterAngle(eastl::string name, float angle);

        float GetLightConeOuterAngle(eastl::string name);

        VkDescriptorSetLayout CreateLightDescriptorSetLayout();

        VkDescriptorSet CreateLightDescriptorSet(size_t threadID, size_t pipelineID, size_t set, VkDescriptorSetLayout layout);

        VkDescriptorSet GetLightDescriptorSet(size_t threadID, size_t pipelineID, size_t set);

        VkFramebuffer GetFrameBuffer();

        VulkanDescriptorPool* GetDescriptorPool(size_t thread);

        size_t GetThreadCount();

    protected:
        void CreateInstance();
        void FindPhysicalDevice();
        void CreateLogicalDevice();
        void CreateSwapChain();
        void GetSwapChainImages();
        void CreateSwapChainImageViews();
        void CreateGraphicsCommandPool();
        void CreateComputeCommandPool();
        void CreateVmaAllocator();
        void CreateDepthImage();
        void CreateAttachmentImages();
        void CreateRenderPass();
        void CreateFramebuffers();
        void GenerateCommandBuffers();
        void CreateDescriptorPool();
        void InitImGui();
        void CreateSemaphores();
        void CreateCompositingPipeline();
        void CreateGBufferRenderPipeline();
        void CreateSsaoPipelines();
        void CreateRenderers();
        void AllocateThreads();

        void RecreateSwapChain();

        void DestroyInstance();
        void DestroyLogicalDevice();
        void DestroySwapChain();
        void DestroySwapChainImageViews();
        void DestroyGraphicsCommandPool();
        void DestroyComputeCommandPool();
        void DestroyVmaAllocator();
        void DestroyDepthImage();
        void DestroyAttachmentImages();
        void DestroyRenderPass();
        void DestroyFramebuffers();
        void DestroyDecriptorPool();
        void DestroyImGui() const;
        void DestroySemaphores();
        void DestroyCompositingPipeline();
        void DestroyGBufferRenderPipeline();
        void DestroySsaoPipelines();
        void DestroyRenderers();
        void DestroyThreads();

        VkFormat VulkanRenderer::FindSupportedDepthFormat(const eastl::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features);

        eastl::unique_ptr<VulkanInstance> vulkanInstance_;
        eastl::unique_ptr<VulkanPhysicalDevice> vulkanPhysicalDevice_;
        eastl::unique_ptr<VulkanLogicalDevice> vulkanLogicalDevice_;
        eastl::vector<eastl::shared_ptr<VulkanDescriptorPool>> vulkanDescriptorPools_;

        /*
        VulkanInstance* vulkanInstance;
        VulkanPhysicalDevice* vulkanPhysicalDevice;
        VulkanLogicalDevice* vulkanLogicalDevice;
        VulkanDescriptorPool* vulkanDescriptorPool;*/

        VulkanDeviceFeatures_t requiredFeatures;

        eastl::weak_ptr<VulkanWindow> window;

        VkSurfaceKHR surface;



#pragma region Swapchain

        VkSwapchainKHR swapChain;

        uint32_t imageCount;
        VkFormat swapChainImageFormat;
        VkExtent2D swapChainImageExtent;

        uint32_t currentImage;
        uint32_t prevImage;

        VkCommandPool graphicsCommandPool;
        VkCommandPool computeCommandPool;

        eastl::vector<VkImage> swapChainImages;
        eastl::vector<VkImageView> swapChainImageViews;

#pragma endregion

#pragma region Depth image

        VkImage depthImage;
        VkImageView depthImageView;
        VmaAllocation depthImageAllocation;
        VmaAllocationInfo depthImageAllocationInfo;

        VkFormat depthImageFormat;

#pragma endregion

#pragma region Renderpass

        enum class GBufferAttachments {
            ALBEDO_ATTACHMENT,
            POSITION_ATTACHMENT,
            NORMAL_ATTACHMENT,
            DEPTH_ATTACHMENT,
            ATTACHMENT_COUNT
        };

        enum class SsaoAttachments {
            SSAO_ATTACHMENT,
            ATTACHMENT_COUNT
        };

        enum class RenderPassAttachments {
            COLOR_ATTACHMENT = 0,
            ALBEDO_ATTACHMENT,
            POSITION_ATTACHMENT,
            NORMAL_ATTACHMENT,
            SSAO_BLUR_ATTACHMENT,
            RENDER_ATTACHMENT,
            IMGUI_ATTACHMENT,
            DEPTH_ATTACHMENT,
            ATTACHMENT_COUNT
        };


        eastl::vector<VkAttachmentDescription> gBufferPassAttachments;
        eastl::vector<VkSubpassDescription> gBufferPassSubPasses;

        eastl::vector<VkAttachmentDescription> ssaoPassAttachments;
        eastl::vector<VkSubpassDescription> ssaoPassSubPasses;

        eastl::vector<VkAttachmentDescription> renderPassAttachments;
        eastl::vector<VkSubpassDescription> renderPassSubPasses;

        VkRenderPass gBufferPass;
        VkRenderPass ssaoPass;
        VkRenderPass renderPass;

#pragma endregion

#pragma region Attachment images

        VkImage imguiImage;
        VkImageView imguiImageView;
        VmaAllocation imguiImageAllocation;
        VmaAllocationInfo imguiImageAllocationInfo;

        VkImage renderImage;
        VkImageView renderImageView;
        VmaAllocation renderImageAllocation;
        VmaAllocationInfo renderImageAllocationInfo;

        VkImage albedoImage;
        VkImageView albedoImageView;
        VmaAllocation albedoImageAllocation;
        VmaAllocationInfo albedoImageAllocationInfo;

        VkImage positionImage;
        VkImageView positionImageView;
        VmaAllocation positionImageAllocation;
        VmaAllocationInfo positionImageAllocationInfo;

        VkImage normalImage;
        VkImageView normalImageView;
        VmaAllocation normalImageAllocation;
        VmaAllocationInfo normalImageAllocationInfo;

        VkImage ssaoImage;
        VkImageView ssaoImageView;
        VmaAllocation ssaoImageAllocation;
        VmaAllocationInfo ssaoImageAllocationInfo;

        VkImage ssaoBlurImage;
        VkImageView ssaoBlurImageView;
        VmaAllocation ssaoBlurImageAllocation;
        VmaAllocationInfo ssaoBlurImageAllocationInfo;

        VkSampler sampler;

#pragma endregion

#pragma region Framebuffers

        eastl::vector<VkFramebuffer> framebuffers;

        VkFramebuffer gBufferFrameBuffer;
        VkFramebuffer ssaoFrameBuffer;

#pragma endregion

#pragma region CommandBuffers

        eastl::vector<VkCommandBuffer> primaryRenderCommandBuffers_;
        eastl::vector<VkCommandBuffer> primaryComputeCommandBuffers_;

        eastl::vector<eastl::vector<VkCommandBuffer>> staticMeshShadowCommandBuffers_;
        eastl::vector<eastl::vector<VkCommandBuffer>> skeletalMeshShadowCommandBuffers_;
        eastl::vector<eastl::vector<VkCommandBuffer>> gBufferShadowCommandBuffers_;

        VkCommandBuffer compositeCommandBuffer_;

        VkCommandBuffer gBufferRenderCommandBuffer_;

        eastl::vector<VkCommandBuffer> imguiCommandBuffers_;

        VkCommandBuffer currentBuffer_;
        VkCommandBuffer currentComputeBuffer_;

        eastl::vector<VkCommandBuffer> spriteRenderCommandBuffers_;

        eastl::vector<VkCommandBuffer> debugRenderCommandBuffers_;

        eastl::vector<VkCommandBuffer> staticMeshCommandBuffers_;

        eastl::vector<VkCommandBuffer> skeletalMeshCommandBuffers_;

        eastl::vector<VkCommandBuffer> clearStencilCommandBuffers_;

        void GenerateSecondaryCommandBuffers(VkCommandBuffer *buffers, uint32_t count);
        void DestroySecondaryCommandBuffers(VkCommandBuffer*buffers, uint32_t count);

#pragma endregion

#pragma region Pipelines

        eastl::unique_ptr<VulkanPipeline> compositingPipeline_;

        eastl::unique_ptr<VulkanPipeline> gBufferRenderPipeline_;

        eastl::unique_ptr<VulkanPipeline> ambientLightPipeline_;

        eastl::unique_ptr<VulkanPipeline> ssaoPipeline_;
        eastl::unique_ptr<VulkanPipeline> ssaoBlurPipeline_;

        VkDescriptorSet gBufferAttachmentDescriptorSet_;

        VkDescriptorSet SceneInfoDescriptorSet_;

        VkDescriptorSet CompositingAttachmentDescriptorSet_;

        VkDescriptorSet ssaoSamplerDescriptor_;

        VkDescriptorSet projectionDescriptor_;

        VkBuffer vertexBuffer_;
        VmaAllocation vertexBufferAllocation_;

        eastl::unique_ptr<VulkanBuffer> ssaoKernelBuffer_;
        eastl::unique_ptr<VulkanBuffer> projectionBuffer_;

        glm::mat4 projection_;

#pragma endregion

#pragma region Renderers

        eastl::unique_ptr<VulkanSpriteRenderer> vulkanSpriteRenderer;
        eastl::unique_ptr<VulkanDebugRenderer> vulkanDebugRenderer;
        eastl::unique_ptr<VulkanStaticMeshRenderer> vulkanStaticMeshRenderer;
        eastl::unique_ptr<VulkanSkeletalMeshRenderer> vulkanSkeletalMeshRenderer;

#pragma endregion

#pragma region Scene

        eastl::unique_ptr<VulkanBuffer> sceneDataBuffer;
        eastl::unique_ptr<VulkanBuffer> lightBuffer;

        eastl::array<Light, 1024> lightData;

        typedef struct {
            int lightCount;
            glm::vec4 viewPos;
        }SceneInfo;

        int activeLights;

        SceneInfo scene;

        typedef struct {
            size_t lightDataIndex;
            Light light;
            eastl::string name;
            LightType type;
            bool active;
        }LightInfo;

        eastl::map<eastl::string, LightInfo> lights;

        eastl::vector<eastl::vector<eastl::vector<VkDescriptorSet>>> lightDescriptorSets_;

        bool lightDataChanged;
        bool lightDataRestructured;

        void RestructureLights();

        void UpdateLightData();

#pragma endregion

#pragma region Threads

        struct ThreadInfo {
            std::thread thread;
            std::packaged_task<void()> task;
            std::future<void> future;
            bool initialized = false;
            size_t threadId;
            VkCommandPool commandPool;
        };

        eastl::vector<ThreadInfo*> threads;

        ThreadInfo* GetFreeThread();
        void JoinAllThreads();
        void ResetCommandPools();

#pragma endregion

        VmaAllocator vmaAllocator_;

        eastl::vector<VkSemaphore> imageAvailableSemaphores_;
        eastl::vector<VkSemaphore> renderFinishedSemaphores_;
        eastl::vector<VkSemaphore> computeFinishedSemaphores_;

        eastl::vector<VkFence> drawingFinishedFences_;
        eastl::vector<VkFence> computeFinishedFences_;

        VkClearValue clearValue;

        bool initialized;

        bool firstRender;

        bool resized;

    };
} // namespace Engine
#endif // USING_VULKAN