render_stage.h

#pragma once
 
#include "pixelbullet/core/color.h"
#include "pixelbullet/graphics/images/image_depth.h"
#include "pixelbullet/graphics/renderpass/framebuffers.h"
#include "pixelbullet/graphics/renderpass/renderpass.h"
#include "pixelbullet/graphics/renderpass/swapchain.h"
 
#include <glm/glm.hpp>
 
#include <map>
 
namespace pixelbullet
{
class Graphics;
class RenderTarget2D;
class Window;
 
class Attachment
{
public:
    enum class Type
    {
        RenderTarget,
        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)
        : binding_(binding)
        , name_(std::move(name))
        , type_(type)
        , multisampled_(multisampled)
        , format_(format)
        , clear_color_(clearColour)
    {
    }
 
    uint32_t GetBinding() const
    {
        return binding_;
    }
    const std::string& GetName() const
    {
        return name_;
    }
    Type GetType() const
    {
        return type_;
    }
    bool IsMultisampled() const
    {
        return multisampled_;
    }
    VkFormat GetFormat() const
    {
        return format_;
    }
    const Color& GetClearColour() const
    {
        return clear_color_;
    }
 
private:
    uint32_t binding_;
    std::string name_;
    Type type_;
    bool multisampled_;
    VkFormat format_;
    Color clear_color_;
};
 
class SubpassType
{
public:
    SubpassType(uint32_t binding, std::vector<uint32_t> attachmentBindings)
        : binding_(binding)
        , attachment_bindings_(std::move(attachmentBindings))
    {
    }
 
    uint32_t GetBinding() const
    {
        return binding_;
    }
    const std::vector<uint32_t>& GetAttachmentBindings() const
    {
        return attachment_bindings_;
    }
 
private:
    uint32_t binding_;
    std::vector<uint32_t> attachment_bindings_;
};
 
class RenderArea
{
public:
    explicit RenderArea(const glm::uvec2& extent = {}, const glm::ivec2& offset = {})
        : extent_(extent)
        , offset_(offset)
    {
    }
 
    bool operator==(const RenderArea& rhs) const
    {
        return extent_ == rhs.extent_ && offset_ == rhs.offset_;
    }
 
    bool operator!=(const RenderArea& rhs) const
    {
        return !(*this == rhs);
    }
 
    const glm::uvec2& GetExtent() const
    {
        return extent_;
    }
    void SetExtent(const glm::uvec2& extent)
    {
        this->extent_ = extent;
    }
 
    const glm::ivec2& GetOffset() const
    {
        return offset_;
    }
    void SetOffset(const glm::ivec2& offset)
    {
        this->offset_ = offset;
    }
 
    float GetAspectRatio() const
    {
        return aspect_ratio_;
    }
    void SetAspectRatio(float aspectRatio)
    {
        this->aspect_ratio_ = aspectRatio;
    }
 
private:
    glm::uvec2 extent_;
    glm::ivec2 offset_;
    float aspect_ratio_ = 1.0f;
};
 
class Viewport
{
public:
    Viewport() = default;
 
    explicit Viewport(const glm::uvec2& size)
        : size_(size)
    {
    }
 
    const glm::vec2& GetScale() const
    {
        return scale_;
    }
    void SetScale(const glm::vec2& scale)
    {
        this->scale_ = scale;
    }
 
    const std::optional<glm::uvec2>& GetSize() const
    {
        return size_;
    }
    void SetSize(const std::optional<glm::uvec2>& size)
    {
        this->size_ = size;
    }
 
    const glm::ivec2& GetOffset() const
    {
        return offset_;
    }
    void SetOffset(const glm::ivec2& offset)
    {
        this->offset_ = offset;
    }
 
private:
    glm::vec2 scale_{ 1.0f, 1.0f };
    std::optional<glm::uvec2> size_;
    glm::ivec2 offset_;
};
 
class RenderStage
{
    friend class Graphics;
 
public:
    explicit RenderStage(std::vector<Attachment> images = {}, std::vector<SubpassType> subpasses = {},
                         const Viewport& viewport = Viewport());
 
    void Update(const Graphics& graphics);
    void Rebuild(const Graphics& graphics, 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 Descriptor* GetDescriptor(uint32_t binding) const;
    const VkFramebuffer& GetActiveFramebuffer(uint32_t activeSwapchainImage) const;
 
    const std::vector<Attachment>& GetAttachments() const
    {
        return attachments_;
    }
    const std::vector<SubpassType>& GetSubpasses() const
    {
        return subpasses_;
    }
 
    Viewport& GetViewport()
    {
        return viewport_;
    }
    void SetViewport(const Viewport& viewport)
    {
        this->viewport_ = viewport;
    }
 
    const RenderArea& GetRenderArea() const
    {
        return render_area_;
    }
 
    bool IsOutOfDate() const
    {
        return out_of_date_;
    }
 
    const Renderpass* GetRenderpass() const
    {
        return renderpass_.get();
    }
    const ImageDepth* GetDepthStencil() const
    {
        return depth_stencil_.get();
    }
    const Framebuffers* GetFramebuffers() const
    {
        return framebuffers_.get();
    }
    const std::vector<VkClearValue>& GetClearValues() const
    {
        return clear_values_;
    }
    uint32_t GetAttachmentCount(uint32_t subpass) const
    {
        return subpass_attachment_count_[subpass];
    }
    bool HasDepth() const
    {
        return depth_attachment_.has_value();
    }
    bool HasSwapchain() const
    {
        return swapchain_attachment_.has_value();
    }
    bool IsMultisampled(uint32_t subpass) const
    {
        return subpass_multisampled_[subpass];
    }
 
private:
    std::vector<Attachment> attachments_;
    std::vector<SubpassType> subpasses_;
 
    Viewport viewport_;
 
    std::unique_ptr<Renderpass> renderpass_;
    std::unique_ptr<ImageDepth> depth_stencil_;
    std::unique_ptr<Framebuffers> framebuffers_;
 
    std::map<std::string, const Descriptor*> descriptors_;
    std::map<uint32_t, const Descriptor*> descriptors_by_binding_;
 
    std::vector<VkClearValue> clear_values_;
    std::vector<uint32_t> subpass_attachment_count_;
    std::optional<Attachment> depth_attachment_;
    std::optional<Attachment> swapchain_attachment_;
    std::vector<bool> subpass_multisampled_;
 
    RenderArea render_area_;
    bool out_of_date_ = false;
};
} // namespace pixelbullet