framebuffer.h

#ifndef OE_RENDER_FRAMEBUFFER_H
#define OE_RENDER_FRAMEBUFFER_H
 
#include <map>
#include <glm/vec2.hpp>
#include <glm/vec4.hpp>
#include <memory>
#include <span>
#include "texture.h"
#include "../util/non_copyable.h"
 
namespace oe::render
{
    enum TargetBuffer : int
    {
        COLOR_BUFFER = 0x4000,
        DEPTH_BUFFER = 0x0100,
        STENCIL_BUFFER = 0x0400,
 
        ALL = 0x4500,
    };

    struct MultipleFramebufferInfo
    {
        std::span<glm::ivec2> dimensions;
    };

    class Framebuffer : public oe::util::NonCopyable
    {
        public:
            Framebuffer(const glm::ivec2& dimensions);

            Framebuffer(const glm::ivec2& dimensions, uint32_t id):
                _width(dimensions.x), _height(dimensions.y),
                _fbo(id)
            {}
 
            Framebuffer(const Framebuffer&) = delete;
            Framebuffer& operator=(const Framebuffer&) = delete;
 
            Framebuffer(Framebuffer&& other) noexcept
            {
                _fbo = other._fbo;
                _rbo = other._rbo;
                _width = other._width;
                _height = other._height;
 
                // Prevent releasing handls when other is destroyed
                other._fbo = 0;
                other._rbo = 0;
            }
 
            Framebuffer(const uint32_t width, const uint32_t height);
            ~Framebuffer();

            std::shared_ptr<Texture> addColorAttachment(const uint32_t attachment_level = 0, const uint32_t internal_format = 0, const uint32_t format = 0, const uint32_t type = 0,
                const uint32_t filter = 0, const uint8_t max_mips = 1
            );

            void addDepthAttachment(const uint32_t format = 0, const uint32_t type = 0, const uint32_t filter = 0);

            void setDepthAttachment(std::shared_ptr<Texture> texture);

            void setTextureAttachment(const uint32_t attachment_level, std::shared_ptr<Texture> texture, const int32_t mip_level = 0);

            void setTextureAttachment(const uint32_t attachment_level, Texture* texture, const int32_t mip_level = 0);

            void clearContents(const glm::vec4& color = glm::vec4(0.f), const int& target = 0);

            void beginRender(const bool resize_viewport = true);

            void endRender();

            operator bool();

            inline const std::shared_ptr<Texture>& getColorAttachment(const uint32_t attachment_level) const
            {
                return _color_attachments.at(attachment_level);
            }

            inline const std::shared_ptr<Texture>& getDepthAttachment() const
            {
                return _depth_attachment;
            }

            void blitFrom(
                const Framebuffer* src,
                const glm::ivec4& src_bounds = glm::ivec4(0),
                const glm::ivec4& target_bounds = glm::ivec4(0),
                const TargetBuffer& type = TargetBuffer::ALL,
                const uint8_t color_attachment_src = 0,
                const uint8_t color_attachment_dest = 0,
                const bool usefilter = false
            );

            void blitTo(
                Framebuffer* target,
                const glm::ivec4& src_bounds = glm::ivec4(0),
                const glm::ivec4& target_bounds = glm::ivec4(0),
                const TargetBuffer& type = TargetBuffer::ALL,
                const uint8_t color_attachment_src = 0,
                const uint8_t color_attachment_dest = 0,
                const bool usefilter = false
            ) const;

            void copyFrom(Framebuffer* source, const TargetBuffer& type = TargetBuffer::ALL)
            {
                blitFrom(source, {}, {}, type);
            }

            void blitToDefault(const uint8_t color_attachment_src = 0, const bool& usefilter = false) const;
 
            /*
             * Blit textures using quad rendering
             * faster than a classic blit
             */
             //void blitTexture(render::Texture* target, const glm::ivec4& src_bounds, const glm::ivec4& target_bounds, const TargetBuffer& type, const bool& usefilter = false);

            inline glm::ivec2 getDimensions() const noexcept
            {
                return {_width, _height};
            }
 
            #ifdef OXYGEN_ENGINE_DEBUG_VALIDATE_ORDERED_OPERATIONS
                bool is_between_begin_end = false;
            #endif
 
        private:
            void _update_color_attachments();
            void _clear_all_color_attachments(const glm::vec4& color);
 
            static void _blit(
                const Framebuffer* src,
                Framebuffer* target,
                const glm::ivec4& src_bounds,
                const glm::ivec4& target_bounds,
                const TargetBuffer& type,
                const uint8_t color_attachment_src,
                const uint8_t color_attachment_dest,
                const bool usefilter
            );
 
            std::map<uint32_t, std::shared_ptr<Texture>> _color_attachments;
            std::shared_ptr<Texture> _depth_attachment = {};
 
            uint32_t _width = 0;
            uint32_t _height = 0;
            uint32_t _fbo = 0;
            uint32_t _rbo = 0;
 
            friend void generateMultipleFramebuffers(MultipleFramebufferInfo, std::vector<Framebuffer>&);
    };

    void generateMultipleFramebuffers(MultipleFramebufferInfo input, std::vector<Framebuffer>& result);
}
 
#endif