graphics.h

#pragma once
 
#include "pixelbullet/graphics/renderer.h"
#include "pixelbullet/time/elapsed.h"
 
#include <volk.h>
 
#include <filesystem>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
namespace pixelbullet
{
struct ApplicationSpecification;
class CommandPool;
class RenderStage;
class Descriptor;
class PhysicalDevice;
class LogicalDevice;
class Swapchain;
class CommandBuffer;
class Instance;
class RenderTarget2D;
class Surface;
class Window;
 
class Graphics
{
public:
    enum class PrepareFrameOutcome
    {
        Skipped,
        Rebuilt,
        Ready
    };
 
    enum class RenderFrameOutcome
    {
        Skipped,
        Rendered
    };
 
    enum class FrameOutcome
    {
        Skipped,
        Rebuilt,
        Rendered
    };
 
    Graphics(const ApplicationSpecification& specification, Window& window);
    ~Graphics();
 
    PrepareFrameOutcome PrepareFrame();
    RenderFrameOutcome RenderPreparedFrame();
    FrameOutcome Update();
 
    static std::string StringifyResultVk(VkResult result);
    static void CheckVk(VkResult result);
 
    void CaptureScreenshot(const std::filesystem::path& filename, std::size_t id = 0) const;
 
    std::shared_ptr<CommandPool> GetCommandPool(VkQueueFlagBits queueType = VK_QUEUE_GRAPHICS_BIT,
                                                const std::thread::id& threadId = std::this_thread::get_id()) const;
 
    Renderer* GetRenderer() const
    {
        return renderer_.get();
    }
 
    void SetRenderer(std::unique_ptr<Renderer>&& renderer);
 
    const RenderStage* GetRenderStage(uint32_t index) const;
 
    const Descriptor* GetAttachment(const std::string& name) const;
    const RenderTarget2D* GetRenderTarget(const std::string& name) const;
 
    const PhysicalDevice* GetPhysicalDevice() const
    {
        return physical_device_.get();
    }
    const LogicalDevice* GetLogicalDevice() const
    {
        return logical_device_.get();
    }
    const VkPipelineCache& GetPipelineCache() const
    {
        return pipeline_cache_;
    }
 
    const Surface* GetSurface(std::size_t id) const
    {
        return surfaces_[id].get();
    }
    const Swapchain* GetSwapchain(std::size_t id) const
    {
        return swapchains_[id].get();
    }
    bool HasSwapchain(std::size_t id) const
    {
        return id < swapchains_.size() && static_cast<bool>(swapchains_[id]);
    }
    bool HasPreparedFrame() const
    {
        return prepared_frame_ready_;
    }
    uint32_t GetPreparedImageIndex(std::size_t id) const
    {
        ASSERT(prepared_frame_ready_ && HasSwapchain(id), "No prepared swapchain image is available");
        return swapchains_[id]->GetActiveImageIndex();
    }
    void SetFramebufferResized(std::size_t id)
    {
        per_surface_buffers_[id]->framebuffer_resized = true;
    }
 
    const Instance* GetInstance() const
    {
        return instance_.get();
    }
    const Window& GetWindow() const
    {
        return window_;
    }
    Window& GetWindow()
    {
        return window_;
    }
 
private:
    void CreatePipelineCache();
    void ResetRenderStages();
    void RebuildRenderStages(bool recreateSwapchain);
    void RecreateSwapchain();
    void RecreateCommandBuffers(std::size_t id);
    void RebuildRenderTargets();
    void RecreateAttachmentsMap();
    void StartRenderpass(std::size_t id, RenderStage& renderStage);
    bool EndRenderpass(std::size_t id, RenderStage& renderStage);
 
private:
    const ApplicationSpecification& specification_;
    Window& window_;
    std::unique_ptr<Renderer> renderer_;
    std::map<std::string, const Descriptor*> attachments_;
    std::map<std::string, std::unique_ptr<RenderTarget2D>> render_targets_;
    std::vector<std::unique_ptr<Swapchain>> swapchains_;
    bool prepared_frame_ready_ = false;
 
    using CommandPoolKey = std::pair<std::thread::id, VkQueueFlagBits>;
 
    mutable std::map<CommandPoolKey, std::shared_ptr<CommandPool>> command_pools_;
    mutable std::mutex command_pools_mutex_;
    Elapsed elapsed_purge_;
 
    struct PerSurfaceBuffers
    {
        std::vector<VkSemaphore> present_completes;
        std::vector<VkSemaphore> render_completes;
        std::vector<VkFence> flight_fences;
        std::vector<VkFence> image_fences;
        std::size_t current_frame = 0;
        bool framebuffer_resized = false;
 
        std::vector<std::unique_ptr<CommandBuffer>> command_buffers;
    };
    std::vector<std::unique_ptr<PerSurfaceBuffers>> per_surface_buffers_;
 
    std::unique_ptr<Instance> instance_;
    std::unique_ptr<PhysicalDevice> physical_device_;
    std::unique_ptr<LogicalDevice> logical_device_;
    VkPipelineCache pipeline_cache_ = VK_NULL_HANDLE;
    std::vector<std::unique_ptr<Surface>> surfaces_;
};
} // namespace pixelbullet