Graphics.hpp

#pragma once
 
#include "PixelBullet/Graphics/Renderer.hpp"
#include "PixelBullet/Time/Elapsed.hpp"
 
#include <volk.h>
 
#include <filesystem>
#include <map>
#include <memory>
#include <string>
#include <thread>
#include <vector>
 
namespace PixelBullet
{
    class CommandPool;
    class RenderStage;
    class Descriptor;
    class PhysicalDevice;
    class LogicalDevice;
    class Swapchain;
    class CommandBuffer;
    class Instance;
    class Surface;
    class VirtualPath;
 
    class Graphics
    {
    public:
        Graphics();
        ~Graphics();
 
        void Update();
 
        static std::string StringifyResultVk(VkResult result);
        static void CheckVk(VkResult result);
 
        template <typename T>
        inline static const T* SafeVkPtr(const std::vector<T>& vec)
        {
            return vec.empty() ? nullptr : vec.data();
        }
 
        template <typename T, std::size_t N>
        inline static const T* SafeVkPtr(const std::array<T, N>& arr)
        {
            return N == 0 ? nullptr : arr.data();
        }
 
        void CaptureScreenshot(const VirtualPath& filename, std::size_t id = 0) const;
 
        const std::shared_ptr<CommandPool>&
        GetCommandPool(const std::thread::id& threadId = std::this_thread::get_id());
 
        Renderer* GetRenderer() const
        {
            return m_Renderer.get();
        }
 
        void SetRenderer(std::unique_ptr<Renderer>&& renderer)
        {
            this->m_Renderer = std::move(renderer);
        }
 
        const RenderStage* GetRenderStage(uint32_t index) const;
 
        const Descriptor* GetAttachment(const std::string& name) const;
 
        const PhysicalDevice* GetPhysicalDevice() const
        {
            return m_PhysicalDevice.get();
        }
        const LogicalDevice* GetLogicalDevice() const
        {
            return m_LogicalDevice.get();
        }
        const VkPipelineCache& GetPipelineCache() const
        {
            return m_PipelineCache;
        }
 
        const Surface* GetSurface(std::size_t id) const
        {
            return m_Surfaces[id].get();
        }
        const Swapchain* GetSwapchain(std::size_t id) const
        {
            return m_Swapchains[id].get();
        }
        void SetFramebufferResized(std::size_t id)
        {
            m_PerSurfaceBuffers[id]->FramebufferResized = true;
        }
 
        const Instance* GetInstance() const
        {
            return m_Instance.get();
        }
 
    private:
        void CreatePipelineCache();
        void ResetRenderStages();
        void RecreateSwapchain();
        void RecreateCommandBuffers(std::size_t id);
        void RecreatePass(std::size_t id, RenderStage& renderStage);
        void RecreateAttachmentsMap();
        bool StartRenderpass(std::size_t id, RenderStage& renderStage);
        void EndRenderpass(std::size_t id, RenderStage& renderStage);
 
    private:
        std::unique_ptr<Renderer> m_Renderer;
        std::map<std::string, const Descriptor*> m_Attachments;
        std::vector<std::unique_ptr<Swapchain>> m_Swapchains;
 
        std::map<std::thread::id, std::shared_ptr<CommandPool>> m_CommandPools;
        Elapsed m_ElapsedPurge;
 
        struct PerSurfaceBuffers
        {
            std::vector<VkSemaphore> PresentCompletes;
            std::vector<VkSemaphore> RenderCompletes;
            std::vector<VkFence> FlightFences;
            std::size_t CurrentFrame = 0;
            bool FramebufferResized = false;
 
            std::vector<std::unique_ptr<CommandBuffer>> CommandBuffers;
        };
        std::vector<std::unique_ptr<PerSurfaceBuffers>> m_PerSurfaceBuffers;
 
        std::unique_ptr<Instance> m_Instance;
        std::unique_ptr<PhysicalDevice> m_PhysicalDevice;
        std::unique_ptr<LogicalDevice> m_LogicalDevice;
        VkPipelineCache m_PipelineCache = VK_NULL_HANDLE;
        std::vector<std::unique_ptr<Surface>> m_Surfaces;
    };
} // namespace PixelBullet