spk_frame_buffer_object.hpp

#pragma once
 
#include "structure/design_pattern/spk_activable_object.hpp"
#include "structure/design_pattern/spk_synchronizable_object.hpp"
#include "structure/graphics/spk_color.hpp"
#include "structure/math/spk_vector2.hpp"
#include "structure/opengl/spk_opengl_includes.hpp"
#include "structure/opengl/spk_texture_object.hpp"
#include "structure/opengl/spk_view_region.hpp"
#include "utils/spk_opengl_utils.hpp"
 
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <ostream>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace spk
{
    namespace OpenGL
    {
        class FrameBufferObject : public spk::ActivableObject, public spk::SynchronizableObject
        {
        public:
            class Attachment : public TextureObject
            {
                friend class FrameBufferObject;
 
            public:
                enum class Type
                {
                    GreyScale,
                    TwoChannelColor,
                    ThreeChannelColor,
                    Color,
                    Depth,
                    DepthStencil
                };
 
            private:
                using TextureObject::clearData;
                using TextureObject::resize;
                using TextureObject::setData;
                using TextureObject::setFormat;
                using TextureObject::sizeAsBytes;
 
                Type _type;
 
            public:
                explicit Attachment(Type p_type = Type::Color) :
                    TextureObject(),
                    _type(p_type)
                {
                    switch (p_type)
                    {
 
                    case Attachment::Type::GreyScale:
                        setFormat(spk::OpenGL::TextureObject::Format::GreyLevel);
                        break;
 
                    case Attachment::Type::TwoChannelColor:
                        setFormat(spk::OpenGL::TextureObject::Format::DualChannel);
                        break;
 
                    case Attachment::Type::ThreeChannelColor:
                        setFormat(spk::OpenGL::TextureObject::Format::RGB);
                        break;
 
                    case Attachment::Type::Color:
                        setFormat(spk::OpenGL::TextureObject::Format::RGBA);
                        break;
 
                    case Attachment::Type::Depth:
                        setFormat(spk::OpenGL::TextureObject::Format::DepthComponent);
                        break;
 
                    case Attachment::Type::DepthStencil:
                        setFormat(spk::OpenGL::TextureObject::Format::DepthStencil);
                        break;
                    }
                }

                Type type() const noexcept
                {
                    return (_type);
                }
            };
 
        private:
            using SynchronizableObject::forceSynchronization;
            using SynchronizableObject::synchronize;
 
            void _ensureAttachmentTypeAvailability(GLuint p_index, Attachment::Type p_type) const;
            void _ensureAttachmentsValidity();
            void _activateAttachment(GLuint p_index, Attachment &p_attachment);
            void _activateAttachments();
            void _attachTexture(GLuint p_index, Attachment &p_attachment);
            void _attachAllTextures();
            void _configureDrawBuffers();
 
            static GLenum _pixelDataType(TextureObject::Format p_format);
            static std::size_t _bytesPerPixel(TextureObject::Format p_format);
 
            void _onSynchronize() override;
            void _registerCallbacks();
 
            const spk::OpenGL::ViewRegion *_viewRegionWhenActivating = nullptr;
            spk::Extend2D _windowSizeWhenActivating = {};
            GLuint _activeFrameBufferWhenActivating = 0;
            spk::OpenGL::ViewRegion _viewRegion;
            spk::CachedData<GLuint> _id{OpenGLUtils::generateFrameBufferObjectID, OpenGLUtils::releaseFrameBufferObjectID};
            std::unordered_map<GLuint, Attachment> _attachments;
            spk::Vector2UInt _size = {0, 0};
 
        public:
            FrameBufferObject();
            FrameBufferObject(const FrameBufferObject &p_other);
            FrameBufferObject &operator=(const FrameBufferObject &p_other);

            void addAttachment(const GLuint &p_index, Attachment::Type p_type);

            Attachment &attachment(const GLuint &p_index);
            const Attachment &attachment(const GLuint &p_index) const;

            bool hasAttachment(const GLuint &p_index) const;

            void resize(const spk::Vector2UInt &p_size);

            const spk::Vector2UInt &size() const;

            const spk::OpenGL::ViewRegion &viewRegion() const;

            void clear(const spk::Color &p_color, const ViewRegion::ClearMask &p_clearMask);

            spk::OpenGL::TextureObject exportAttachmentTexture(GLuint p_index);
        };
 
        std::ostream &operator<<(std::ostream &p_os, const FrameBufferObject::Attachment::Type &p_type);
    }
}