VulkanApp.h

Go to the documentation of this file.

#pragma once

#include "FlingTypes.h"
#include "FlingVulkan.h"
#include "Singleton.hpp"

#include <entt/entity/registry.hpp>
#include <vector>

namespace Fling
{
    enum PipelineFlags
    {
        DEFERRED        = (1u << 0),
        REFLECTIONS     = (1u << 1),
        IMGUI           = (1u << 2),
        CUBEMAP         = (1u << 3),
        DEBUG           = (1u << 4),
        ALL = 0xff
    };

    class Instance;
    class LogicalDevice;
    class PhysicalDevice;
    class Swapchain;
    class FlingWindow;
    class RenderPipeline;
    class CommandBuffer;
    class FirstPersonCamera;
    class DepthBuffer;
    class BaseEditor;

    class VulkanApp : public Singleton<VulkanApp>
    {
    public:

        void Init(PipelineFlags t_Conf, entt::registry& t_Reg, std::shared_ptr<Fling::BaseEditor> t_Editor);
        void Shutdown(entt::registry& t_Reg);

        VulkanApp() = default;
        ~VulkanApp() = default;

        void Update(float DeltaTime, entt::registry& t_Reg);

        inline FlingWindow* GetCurrentWindow() const { return m_CurrentWindow; }
        inline LogicalDevice* GetLogicalDevice() const { return m_LogicalDevice; }
        inline PhysicalDevice* GetPhysicalDevice() const { return m_PhysicalDevice; }
        inline const VkCommandPool GetCommandPool() const { return m_CommandPool; }
        inline FirstPersonCamera* GetCamera() const { return m_Camera; }

    private:
        
        void Prepare();

        void CreateFrameSyncResources();

        void CreateGameWindow(const UINT32 t_width, const UINT32 t_height);

        VkExtent2D ChooseSwapExtent();

        void BuildRenderPipelines(PipelineFlags t_Conf, entt::registry& t_Reg, std::shared_ptr<Fling::BaseEditor> t_Editor);

        void BuildSwapChainResources();

        void BuildGlobalRenderPass();

        void BuildSwapChainFrameBuffer();

        Instance* m_Instance = nullptr;
        LogicalDevice* m_LogicalDevice = nullptr;
        PhysicalDevice* m_PhysicalDevice = nullptr;
        FlingWindow* m_CurrentWindow = nullptr;
        
        // Swap chain related stuff ---------------------------------------------------------------------
        Swapchain* m_SwapChain = nullptr;
        // Depth buffer acts as a container for our swap chain depth attachment
        DepthBuffer* m_DepthBuffer = nullptr;
        // Global render pass for frame buffer usage
        VkRenderPass m_RenderPass = VK_NULL_HANDLE;
        // List of available frame buffers (same as number of swap chain images)
        std::vector<VkFramebuffer> m_SwapChainFrameBuffers;
        std::vector<VkClearValue> m_SwapChainClearVals = std::vector<VkClearValue>(2);

        // Stages that the swap chain needs to wait on in order to present
        VkPipelineStageFlags m_WaitStages = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };

        std::vector<CommandBuffer*> m_DrawCmdBuffers;

        std::vector<VkSemaphore> m_PresentCompleteSemaphores;
        std::vector<VkSemaphore> m_RenderFinishedSemaphores;
        std::vector<VkFence> m_InFlightFences;

        VkSurfaceKHR m_Surface = VK_NULL_HANDLE;
        
        size_t CurrentFrameIndex = 0;

        // Command Buffer pool
        VkCommandPool m_CommandPool = VK_NULL_HANDLE;

        std::vector<RenderPipeline*> m_RenderPipelines;

        FirstPersonCamera* m_Camera = nullptr;

        // #TODO VMA Allocator
    };
}   // namespace Fling