RenderStage.hpp

#pragma once
 
#include "PixelBullet/Graphics/Images/ImageDepth.hpp"
#include "PixelBullet/Graphics/Renderpass/Framebuffers.hpp"
#include "PixelBullet/Graphics/Renderpass/Renderpass.hpp"
#include "PixelBullet/Graphics/Renderpass/Swapchain.hpp"
#include "PixelBullet/Math/Color.hpp"
 
#include <glm/glm.hpp>
 
#include <map>
 
namespace PixelBullet
{
    class Attachment
    {
    public:
        enum class Type
        {
            Image,
            Depth,
            Swapchain
        };
 
        Attachment(uint32_t binding, std::string name, Type type, bool multisampled = false,
                   VkFormat format = VK_FORMAT_R8G8B8A8_UNORM, const Color& clearColour = Color::Black)
            : m_Binding(binding)
            , m_Name(std::move(name))
            , m_Type(type)
            , m_Multisampled(multisampled)
            , m_Format(format)
            , m_ClearColor(clearColour)
        {
        }
 
        uint32_t GetBinding() const
        {
            return m_Binding;
        }
        const std::string& GetName() const
        {
            return m_Name;
        }
        Type GetType() const
        {
            return m_Type;
        }
        bool IsMultisampled() const
        {
            return m_Multisampled;
        }
        VkFormat GetFormat() const
        {
            return m_Format;
        }
        const Color& GetClearColour() const
        {
            return m_ClearColor;
        }
 
    private:
        uint32_t m_Binding;
        std::string m_Name;
        Type m_Type;
        bool m_Multisampled;
        VkFormat m_Format;
        Color m_ClearColor;
    };
 
    class SubpassType
    {
    public:
        SubpassType(uint32_t binding, std::vector<uint32_t> attachmentBindings)
            : m_Binding(binding)
            , m_AttachmentBindings(std::move(attachmentBindings))
        {
        }
 
        uint32_t GetBinding() const
        {
            return m_Binding;
        }
        const std::vector<uint32_t>& GetAttachmentBindings() const
        {
            return m_AttachmentBindings;
        }
 
    private:
        uint32_t m_Binding;
        std::vector<uint32_t> m_AttachmentBindings;
    };
 
    class RenderArea
    {
    public:
        explicit RenderArea(const glm::uvec2& extent = {}, const glm::ivec2& offset = {})
            : m_Extent(extent)
            , m_Offset(offset)
        {
        }
 
        bool operator==(const RenderArea& rhs) const
        {
            return m_Extent == rhs.m_Extent && m_Offset == rhs.m_Offset;
        }
 
        bool operator!=(const RenderArea& rhs) const
        {
            return !(*this == rhs);
        }
 
        const glm::uvec2& GetExtent() const
        {
            return m_Extent;
        }
        void SetExtent(const glm::uvec2& extent)
        {
            this->m_Extent = extent;
        }
 
        const glm::ivec2& GetOffset() const
        {
            return m_Offset;
        }
        void SetOffset(const glm::ivec2& offset)
        {
            this->m_Offset = offset;
        }
 
        float GetAspectRatio() const
        {
            return m_AspectRatio;
        }
        void SetAspectRatio(float aspectRatio)
        {
            this->m_AspectRatio = aspectRatio;
        }
 
    private:
        glm::uvec2 m_Extent;
        glm::ivec2 m_Offset;
        float m_AspectRatio = 1.0f;
    };
 
    class Viewport
    {
    public:
        Viewport() = default;
 
        explicit Viewport(const glm::uvec2& size)
            : m_Size(size)
        {
        }
 
        const glm::vec2& GetScale() const
        {
            return m_Scale;
        }
        void SetScale(const glm::vec2& scale)
        {
            this->m_Scale = scale;
        }
 
        const std::optional<glm::uvec2>& GetSize() const
        {
            return m_Size;
        }
        void SetSize(const std::optional<glm::uvec2>& size)
        {
            this->m_Size = size;
        }
 
        const glm::ivec2& GetOffset() const
        {
            return m_Offset;
        }
        void SetOffset(const glm::ivec2& offset)
        {
            this->m_Offset = offset;
        }
 
    private:
        glm::vec2 m_Scale{ 1.0f, 1.0f };
        std::optional<glm::uvec2> m_Size;
        glm::ivec2 m_Offset;
    };
 
    class RenderStage
    {
        friend class Graphics;
 
    public:
        explicit RenderStage(std::vector<Attachment> images = {}, std::vector<SubpassType> subpasses = {},
                             const Viewport& viewport = Viewport());
 
        void Update();
        void Rebuild(const Swapchain& swapchain);
 
        std::optional<Attachment> GetAttachment(const std::string& name) const;
        std::optional<Attachment> GetAttachment(uint32_t binding) const;
 
        const Descriptor* GetDescriptor(const std::string& name) const;
        const VkFramebuffer& GetActiveFramebuffer(uint32_t activeSwapchainImage) const;
 
        const std::vector<Attachment>& GetAttachments() const
        {
            return m_Attachments;
        }
        const std::vector<SubpassType>& GetSubpasses() const
        {
            return m_Subpasses;
        }
 
        Viewport& GetViewport()
        {
            return m_Viewport;
        }
        void SetViewport(const Viewport& viewport)
        {
            this->m_Viewport = viewport;
        }
 
        const RenderArea& GetRenderArea() const
        {
            return m_RenderArea;
        }
 
        bool IsOutOfDate() const
        {
            return m_OutOfDate;
        }
 
        const Renderpass* GetRenderpass() const
        {
            return m_Renderpass.get();
        }
        const ImageDepth* GetDepthStencil() const
        {
            return m_DepthStencil.get();
        }
        const Framebuffers* GetFramebuffers() const
        {
            return m_Framebuffers.get();
        }
        const std::vector<VkClearValue>& GetClearValues() const
        {
            return m_ClearValues;
        }
        uint32_t GetAttachmentCount(uint32_t subpass) const
        {
            return m_SubpassAttachmentCount[subpass];
        }
        bool HasDepth() const
        {
            return m_DepthAttachment.has_value();
        }
        bool HasSwapchain() const
        {
            return m_SwapchainAttachment.has_value();
        }
        bool IsMultisampled(uint32_t subpass) const
        {
            return m_SubpassMultisampled[subpass];
        }
 
    private:
        std::vector<Attachment> m_Attachments;
        std::vector<SubpassType> m_Subpasses;
 
        Viewport m_Viewport;
 
        std::unique_ptr<Renderpass> m_Renderpass;
        std::unique_ptr<ImageDepth> m_DepthStencil;
        std::unique_ptr<Framebuffers> m_Framebuffers;
 
        std::map<std::string, const Descriptor*> m_Descriptors;
 
        std::vector<VkClearValue> m_ClearValues;
        std::vector<uint32_t> m_SubpassAttachmentCount;
        std::optional<Attachment> m_DepthAttachment;
        std::optional<Attachment> m_SwapchainAttachment;
        std::vector<bool> m_SubpassMultisampled;
 
        RenderArea m_RenderArea;
        bool m_OutOfDate = false;
    };
} // namespace PixelBullet