framebuffer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "gl_functions.hpp"
#include "renderbuffer.hpp"
#include "texture.hpp"
#include "utility.hpp"
 
#include <array>
#include <cstdint>
#include <exception>
#include <functional>
#include <optional>
#include <span>
 
#ifdef STAPLEGL_DEBUG
#include <cstdio>
#endif // STAPLEGL_DEBUG
 
namespace staplegl {
 
enum class fbo_attachment : std::uint8_t {
    NONE = 0x00,
    ATTACH_DEPTH_BUFFER = 0x01,
    ATTACH_STENCIL_BUFFER = 0x02,
    ATTACH_DEPTH_STENCIL_BUFFER = 0x03,
};
 
class framebuffer {
 
public:
    framebuffer() noexcept;
    ~framebuffer();
 
    framebuffer(const framebuffer&) = delete;
    auto operator=(const framebuffer&) -> framebuffer& = delete;
 
    framebuffer(framebuffer&& other) noexcept;
    auto operator=(framebuffer&& other) noexcept -> framebuffer&;
 
    void set_renderbuffer(resolution res, fbo_attachment attachment = fbo_attachment::ATTACH_DEPTH_STENCIL_BUFFER, tex_samples samples = tex_samples::MSAA_X1);
 
    void set_texture(texture_2d const& tex, size_t index = 0) const;
 
    static void set_viewport(resolution res);
 
    static void bind_default()
    {
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
    }
 
    void bind() const;
    static void unbind();
 
    static auto assert_completeness() -> bool
    {
        auto status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
 
        return status == GL_FRAMEBUFFER_COMPLETE;
    }
 
    static void transfer_data(framebuffer const& src, framebuffer const& dst, resolution res)
    {
        glBindFramebuffer(GL_READ_FRAMEBUFFER, src.id());
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dst.id());
 
        glBlitFramebuffer(0, 0, res.width, res.height, 0, 0, res.width, res.height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
    }
 
    [[nodiscard]] constexpr auto id() const -> std::uint32_t
    {
        return m_id;
    }
 
    [[nodiscard]] constexpr auto get_renderbuffer() const -> const std::optional<renderbuffer>&;
 
    [[nodiscard]] constexpr auto attachment() const -> fbo_attachment
    {
        return m_attachment;
    }
 
private:
    std::uint32_t m_id {};
    fbo_attachment m_attachment {};
    std::optional<renderbuffer> m_renderbuffer {};
 
}; // class framebuffer
 
inline framebuffer::framebuffer() noexcept
{
    glGenFramebuffers(1, &m_id);
}
 
inline framebuffer::~framebuffer()
{
    if (m_id != 0) {
        glDeleteFramebuffers(1, &m_id);
    }
}
 
inline framebuffer::framebuffer(framebuffer&& other) noexcept
    : m_id(other.m_id)
    , m_attachment(other.m_attachment)
    , m_renderbuffer(std::move(other.m_renderbuffer))
{
    other.m_id = 0;
}
 
inline auto framebuffer::operator=(framebuffer&& other) noexcept -> framebuffer&
{
    if (this != &other) {
        m_id = other.m_id;
        m_attachment = other.m_attachment;
        m_renderbuffer = std::move(other.m_renderbuffer);
        other.m_id = 0;
    }
    return *this;
}
 
inline void framebuffer::set_renderbuffer(resolution res, fbo_attachment attachment, tex_samples samples)
{
    if (attachment != fbo_attachment::NONE) {
 
        renderbuffer::attachment_type type {};
 
        switch (attachment) {
        case fbo_attachment::ATTACH_DEPTH_BUFFER:
            type = renderbuffer::attachment_type::depth;
            break;
        case fbo_attachment::ATTACH_STENCIL_BUFFER:
            type = renderbuffer::attachment_type::stencil;
            break;
        case fbo_attachment::ATTACH_DEPTH_STENCIL_BUFFER:
            type = renderbuffer::attachment_type::depth_stencil;
            break;
        default:
#ifdef STAPLEGL_DEBUG
            std::fprintf(stderr, STAPLEGL_LINEINFO "invalid attachment enum %d for renderbuffer\n", static_cast<std::uint32_t>(attachment));
#endif
            std::terminate(); // crash and burn, this is unrecoverable
        }
 
        m_attachment = attachment; // in some cases this is a redundant operation, fair enough.
        m_renderbuffer.emplace(res, type, samples);
 
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, static_cast<std::uint32_t>(type), GL_RENDERBUFFER, m_renderbuffer->id());
    } else {
        // unbind the old framebuffer, if present
 
        if (m_attachment == fbo_attachment::NONE) {
            return; // nothing to unbind
        }
 
        renderbuffer::attachment_type type {};
 
        switch (m_attachment) {
        case fbo_attachment::ATTACH_DEPTH_BUFFER:
            type = renderbuffer::attachment_type::depth;
            break;
        case fbo_attachment::ATTACH_STENCIL_BUFFER:
            type = renderbuffer::attachment_type::stencil;
            break;
        case fbo_attachment::ATTACH_DEPTH_STENCIL_BUFFER:
            type = renderbuffer::attachment_type::depth_stencil;
            break;
        default:
            break;
        }
 
        m_attachment = fbo_attachment::NONE;
 
        glFramebufferRenderbuffer(GL_FRAMEBUFFER,
            static_cast<std::uint32_t>(type),
            GL_RENDERBUFFER, 0);
    }
}
 
inline void framebuffer::set_texture(staplegl::texture_2d const& tex, size_t index) const
{
 
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + index, tex.antialias().type, tex.id(), 0);
}
 
inline void framebuffer::set_viewport(staplegl::resolution res)
{
    glViewport(0, 0, res.width, res.height);
}
 
constexpr auto framebuffer::get_renderbuffer() const -> const std::optional<renderbuffer>&
{
    return m_renderbuffer;
}
 
inline void framebuffer::bind() const
{
    glBindFramebuffer(GL_FRAMEBUFFER, m_id);
}
 
inline void framebuffer::unbind()
{
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
 
} // namespace staplegl