render_stage.h

#pragma once
 
#include "pixelbullet/core/color.h"
 
#include <glm/glm.hpp>
 
#include <cstdint>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
namespace pixelbullet
{
class Attachment
{
public:
    enum class Type
    {
        RenderTarget,
        Depth,
        Swapchain
    };
 
    Attachment(uint32_t binding, std::string name, Type type, bool multisampled = false, const Color& clear_colour = Color::black,
               bool shader_readable = false, bool shadow_sampler = false)
        : binding_(binding)
        , name_(std::move(name))
        , type_(type)
        , multisampled_(multisampled)
        , clear_color_(clear_colour)
        , shader_readable_(shader_readable)
        , shadow_sampler_(shadow_sampler)
    {
    }
 
    uint32_t GetBinding() const
    {
        return binding_;
    }
    const std::string& GetName() const
    {
        return name_;
    }
    Type GetType() const
    {
        return type_;
    }
    bool IsMultisampled() const
    {
        return multisampled_;
    }
    const Color& GetClearColour() const
    {
        return clear_color_;
    }
    bool IsShaderReadable() const
    {
        return shader_readable_;
    }
    bool UsesShadowSampler() const
    {
        return shadow_sampler_;
    }
 
private:
    uint32_t binding_;
    std::string name_;
    Type type_;
    bool multisampled_;
    Color clear_color_;
    bool shader_readable_;
    bool shadow_sampler_;
};
 
class SubpassType
{
public:
    SubpassType(uint32_t binding, std::vector<uint32_t> attachment_bindings)
        : binding_(binding)
        , attachment_bindings_(std::move(attachment_bindings))
    {
    }
 
    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 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)
    {
        scale_ = scale;
    }
 
    const std::optional<glm::uvec2>& GetSize() const
    {
        return size_;
    }
    void SetSize(const std::optional<glm::uvec2>& size)
    {
        size_ = size;
    }
 
    const glm::ivec2& GetOffset() const
    {
        return offset_;
    }
    void SetOffset(const glm::ivec2& offset)
    {
        offset_ = offset;
    }
 
private:
    glm::vec2 scale_{ 1.0f, 1.0f };
    std::optional<glm::uvec2> size_;
    glm::ivec2 offset_{ 0, 0 };
};
 
class RenderStage
{
public:
    explicit RenderStage(std::vector<Attachment> images = {}, std::vector<SubpassType> subpasses = {},
                         const Viewport& viewport = Viewport());
    ~RenderStage();
 
    std::optional<Attachment> GetAttachment(const std::string& name) const;
    std::optional<Attachment> GetAttachment(uint32_t binding) const;
 
    const std::vector<Attachment>& GetAttachments() const
    {
        return attachments_;
    }
    const std::vector<SubpassType>& GetSubpasses() const
    {
        return subpasses_;
    }
 
    Viewport& GetViewport()
    {
        return viewport_;
    }
    const Viewport& GetViewport() const
    {
        return viewport_;
    }
    void SetViewport(const Viewport& viewport)
    {
        viewport_ = viewport;
    }
 
private:
    std::vector<Attachment> attachments_;
    std::vector<SubpassType> subpasses_;
    Viewport viewport_;
};
} // namespace pixelbullet