graphics_state_internal.h

#pragma once
 
#include "graphics_frame_runtime_internal.h"
 
#include "pixelbullet/application/launch_gpu_defaults_internal.h"
#include "pixelbullet/graphics/render_device.h"
#include "pixelbullet/graphics/render_target.h"
#include "pixelbullet/graphics/renderer.h"
#include "pixelbullet/time/elapsed.h"
 
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <thread>
#include <vector>
 
namespace pixelbullet
{
struct ApplicationLaunchOptions;
class CommandBuffer;
class CommandPool;
class Descriptor;
class Instance;
class LogicalDevice;
class PhysicalDevice;
class RenderStageRuntime;
class RenderTarget2D;
class ImageDepth;
class Surface;
class Swapchain;
 
class GraphicsStateAccess
{
public:
    static GraphicsState& GetState(Graphics& graphics) noexcept;
    static const GraphicsState& GetState(const Graphics& graphics) noexcept;
};
 
class GraphicsState
{
public:
    using CommandPoolKey = std::pair<std::thread::id, VkQueueFlagBits>;
 
    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;
    };
 
    GraphicsState(Graphics& owner, const ApplicationSpecification& specification, const ApplicationLaunchOptions& launch_options,
                  Window& window);
    ~GraphicsState();
 
    Graphics::FrameOutcome Update();
    GraphicsFrameRuntimeAccess::PrepareFrameOutcome PrepareFrame();
    GraphicsFrameRuntimeAccess::RenderFrameOutcome RenderPreparedFrame();
    void WaitIdle() const;
    void CaptureScreenshot(const std::filesystem::path& filename, std::size_t id) const;
 
    void SetRenderer(std::unique_ptr<Renderer>&& renderer);
    const Descriptor* GetAttachment(const std::string& name) const;
    const ImageDepth* GetDepthAttachment(std::string_view name) const;
    std::optional<RenderTargetView> GetRenderTarget(std::string_view name) const;
    void SetFramebufferResized(std::size_t id);
 
    std::shared_ptr<CommandPool> GetCommandPool(VkQueueFlagBits queue_type = VK_QUEUE_GRAPHICS_BIT,
                                                const std::thread::id& thread_id = std::this_thread::get_id()) const;
 
    const PhysicalDevice* GetPhysicalDevice() const noexcept;
    const LogicalDevice* GetLogicalDevice() const noexcept;
    const VkPipelineCache& GetPipelineCache() const noexcept;
    const Surface* GetSurface(std::size_t id) const noexcept;
    const Swapchain* GetSwapchain(std::size_t id) const noexcept;
    bool HasSwapchain(std::size_t id) const noexcept;
    bool HasPreparedFrame() const noexcept;
    uint32_t GetPreparedImageIndex(std::size_t id) const;
    const Instance* GetInstance() const noexcept;
 
    Graphics& owner;
    application_internal::ResolvedLaunchGpuDefaults launch_gpu_defaults;
    const ApplicationSpecification& specification;
    Window& window;
    RenderDevice render_device;
    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<RenderStageRuntime>> render_stage_runtimes;
    std::vector<std::unique_ptr<Swapchain>> swapchains;
    bool prepared_frame_ready = false;
    mutable std::map<CommandPoolKey, std::shared_ptr<CommandPool>> command_pools;
    mutable std::mutex command_pools_mutex;
    Elapsed elapsed_purge;
    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;
 
private:
    void CreatePipelineCache();
    void ResetRenderStages();
    void RebuildRenderStages(bool recreate_swapchain);
    void RecreateSwapchain();
    void RecreateCommandBuffers(std::size_t id);
    void RebuildRenderTargets();
    void RecreateAttachmentsMap();
    void StartRenderpass(std::size_t id, RenderStageRuntime& render_stage);
    bool EndRenderpass(std::size_t id, RenderStageRuntime& render_stage);
};
} // namespace pixelbullet