spk_pipeline.hpp

#pragma once
 
#include "structure/container/spk_buffer_layout.hpp"
#include "structure/opengl/spk_buffer_object.hpp"
#include "structure/opengl/spk_buffer_set_object.hpp"
#include "structure/opengl/spk_frame_buffer_object.hpp"
#include "structure/opengl/spk_program.hpp"
#include "structure/opengl/spk_sampler_object.hpp"
#include "structure/opengl/spk_shader_storage_buffer_object.hpp"
#include "structure/opengl/spk_uniform_buffer_object.hpp"
#include "structure/opengl/spk_vertex_buffer_object.hpp"
#include "utils/spk_string_utils.hpp"
 
#include <cstddef>
#include <filesystem>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <variant>
#include <vector>
 
namespace spk::Lumina
{
    class Pipeline
    {
    public:
        class Constant
        {
        public:
            enum class Kind
            {
                None,
                UBO,
                SSBO,
                Sampler
            };
 
        private:
            Kind _kind = Kind::None;
            GLuint _bindingPoint = 0;
            std::size_t _size = 0;
            std::variant<std::monostate, spk::OpenGL::UBO, spk::OpenGL::SSBO, spk::OpenGL::SamplerObject> _data;
 
            template <typename TCallable>
            void _withResource(TCallable &&p_callable)
            {
                std::visit(
                    [&](auto &p_resource) {
                        using ResourceType = std::decay_t<decltype(p_resource)>;
                        if constexpr (std::is_same_v<ResourceType, std::monostate>)
                        {
                            throw std::runtime_error("Pipeline constant not initialized");
                        }
                        else
                        {
                            p_callable(p_resource);
                        }
                    },
                    _data);
            }
 
            template <typename TResource>
            TResource &_get()
            {
                if (auto ptr = std::get_if<TResource>(&_data))
                {
                    return *ptr;
                }
                throw std::runtime_error("Pipeline constant does not hold requested resource type");
            }
 
            template <typename TResource>
            const TResource &_get() const
            {
                if (auto ptr = std::get_if<TResource>(&_data))
                {
                    return *ptr;
                }
                throw std::runtime_error("Pipeline constant does not hold requested resource type");
            }
 
        public:
            Constant() = default;
            Constant(Constant &&) = default;
            Constant &operator=(Constant &&) = default;
 
            Constant(const Constant &) = delete;
            Constant &operator=(const Constant &) = delete;

            Kind kind() const noexcept
            {
                return _kind;
            }

            GLuint bindingPoint() const noexcept
            {
                return _bindingPoint;
            }

            std::size_t size() const noexcept
            {
                return _size;
            }

            void setUBO(GLuint p_bindingPoint, std::size_t p_size, spk::OpenGL::BufferObject::Usage p_usage)
            {
                _kind = Kind::UBO;
                _bindingPoint = p_bindingPoint;
                _size = p_size;
                _data.emplace<spk::OpenGL::UBO>(p_bindingPoint, p_usage, p_size);
            }

            void setSSBO(GLuint p_bindingPoint, std::size_t p_size, spk::OpenGL::BufferObject::Usage p_usage)
            {
                _kind = Kind::SSBO;
                _bindingPoint = p_bindingPoint;
                _size = p_size;
                _data.emplace<spk::OpenGL::SSBO>(p_bindingPoint, p_usage, p_size);
            }

            void setSampler(GLint p_uniformLocation, GLuint p_textureUnitIndex)
            {
                _kind = Kind::Sampler;
                _bindingPoint = p_textureUnitIndex;
                _size = 0;
                _data.emplace<spk::OpenGL::SamplerObject>(p_uniformLocation, p_textureUnitIndex);
            }

            void activate()
            {
                _withResource([](auto &p_resource) {
                    p_resource.activate();
                });
            }

            void deactivate()
            {
                _withResource([](auto &p_resource) {
                    p_resource.deactivate();
                });
            }

            spk::OpenGL::UBO &ubo()
            {
                return _get<spk::OpenGL::UBO>();
            }

            const spk::OpenGL::UBO &ubo() const
            {
                return _get<spk::OpenGL::UBO>();
            }

            spk::OpenGL::SSBO &ssbo()
            {
                return _get<spk::OpenGL::SSBO>();
            }

            const spk::OpenGL::SSBO &ssbo() const
            {
                return _get<spk::OpenGL::SSBO>();
            }

            spk::OpenGL::SamplerObject &sampler()
            {
                return _get<spk::OpenGL::SamplerObject>();
            }

            const spk::OpenGL::SamplerObject &sampler() const
            {
                return _get<spk::OpenGL::SamplerObject>();
            }

            operator spk::OpenGL::UBO &()
            {
                return _get<spk::OpenGL::UBO>();
            }

            operator const spk::OpenGL::UBO &() const
            {
                return _get<spk::OpenGL::UBO>();
            }

            operator spk::OpenGL::SSBO &()
            {
                return _get<spk::OpenGL::SSBO>();
            }

            operator const spk::OpenGL::SSBO &() const
            {
                return _get<spk::OpenGL::SSBO>();
            }

            operator spk::OpenGL::SamplerObject &()
            {
                return _get<spk::OpenGL::SamplerObject>();
            }

            operator const spk::OpenGL::SamplerObject &() const
            {
                return _get<spk::OpenGL::SamplerObject>();
            }
        };

        class Object
        {
            friend class Pipeline;
 
        public:
            class Attribute
            {
            public:
                enum class Kind
                {
                    None,
                    UBO,
                    SSBO,
                    Sampler
                };
 
            private:
                Kind _kind = Kind::None;
                GLuint _bindingPoint = 0;
                std::size_t _size = 0;
                GLint _uniformLocation = -1;
                std::variant<std::monostate, spk::OpenGL::UBO, spk::OpenGL::SSBO, spk::OpenGL::SamplerObject> _resource;
 
                template <typename TResource>
                TResource &_getResource()
                {
                    if (auto ptr = std::get_if<TResource>(&_resource))
                    {
                        return *ptr;
                    }
                    throw std::runtime_error("Pipeline attribute does not hold requested resource type");
                }
 
                template <typename TResource>
                const TResource &_getResource() const
                {
                    if (auto ptr = std::get_if<TResource>(&_resource))
                    {
                        return *ptr;
                    }
                    throw std::runtime_error("Pipeline attribute does not hold requested resource type");
                }
 
            public:
                Attribute() = default;
                Attribute(const Attribute &p_other) = default;
                Attribute(Attribute &&p_other) noexcept = default;
                Attribute &operator=(const Attribute &p_other) = default;
                Attribute &operator=(Attribute &&p_other) noexcept = default;

                Kind kind() const noexcept
                {
                    return _kind;
                }

                GLuint bindingPoint() const noexcept
                {
                    return _bindingPoint;
                }

                std::size_t size() const noexcept
                {
                    return _size;
                }

                GLint uniformLocation() const noexcept
                {
                    return _uniformLocation;
                }

                void setUBO(GLuint p_bindingPoint, std::size_t p_size, spk::OpenGL::BufferObject::Usage p_usage)
                {
                    _kind = Kind::UBO;
                    _bindingPoint = p_bindingPoint;
                    _size = p_size;
                    _resource.emplace<spk::OpenGL::UBO>(p_bindingPoint, p_usage, p_size);
                }

                void setSSBO(GLuint p_bindingPoint, std::size_t p_size, spk::OpenGL::BufferObject::Usage p_usage)
                {
                    _kind = Kind::SSBO;
                    _bindingPoint = p_bindingPoint;
                    _size = p_size;
                    _resource.emplace<spk::OpenGL::SSBO>(p_bindingPoint, p_usage, p_size);
                }

                void setSampler(GLint p_uniformLocation, GLuint p_textureUnitIndex)
                {
                    _kind = Kind::Sampler;
                    _bindingPoint = p_textureUnitIndex;
                    _size = 0;
                    _uniformLocation = p_uniformLocation;
                    _resource.emplace<spk::OpenGL::SamplerObject>(p_uniformLocation, p_textureUnitIndex);
                }

                void activate()
                {
                    std::visit(
                        [](auto &p_resource) {
                            using ResourceType = std::decay_t<decltype(p_resource)>;
                            if constexpr (std::is_same_v<ResourceType, std::monostate>)
                            {
                                return;
                            }
                            else
                            {
                                p_resource.activate();
                            }
                        },
                        _resource);
                }

                void deactivate()
                {
                    std::visit(
                        [](auto &p_resource) {
                            using ResourceType = std::decay_t<decltype(p_resource)>;
                            if constexpr (std::is_same_v<ResourceType, std::monostate>)
                            {
                                return;
                            }
                            else
                            {
                                p_resource.deactivate();
                            }
                        },
                        _resource);
                }

                spk::OpenGL::UBO &ubo()
                {
                    return _getResource<spk::OpenGL::UBO>();
                }

                const spk::OpenGL::UBO &ubo() const
                {
                    return _getResource<spk::OpenGL::UBO>();
                }

                spk::OpenGL::SSBO &ssbo()
                {
                    return _getResource<spk::OpenGL::SSBO>();
                }

                const spk::OpenGL::SSBO &ssbo() const
                {
                    return _getResource<spk::OpenGL::SSBO>();
                }

                spk::OpenGL::SamplerObject &sampler()
                {
                    return _getResource<spk::OpenGL::SamplerObject>();
                }

                const spk::OpenGL::SamplerObject &sampler() const
                {
                    return _getResource<spk::OpenGL::SamplerObject>();
                }

                template <typename TResourceType>
                TResourceType &as()
                {
                    static_assert(
                        std::is_same_v<TResourceType, spk::OpenGL::UBO> ||
                            std::is_same_v<TResourceType, spk::OpenGL::SSBO> ||
                            std::is_same_v<TResourceType, spk::OpenGL::SamplerObject>,
                        "Pipeline::Object::Attribute::as only supports UBO, SSBO, or SamplerObject");
 
                    return _getResource<TResourceType>();
                }

                template <typename TResourceType>
                const TResourceType &as() const
                {
                    static_assert(
                        std::is_same_v<TResourceType, spk::OpenGL::UBO> ||
                            std::is_same_v<TResourceType, spk::OpenGL::SSBO> ||
                            std::is_same_v<TResourceType, spk::OpenGL::SamplerObject>,
                        "Pipeline::Object::Attribute::as only supports UBO, SSBO, or SamplerObject");
 
                    return _getResource<TResourceType>();
                }
            };
 
        private:
            Pipeline *_owner = nullptr;
            std::shared_ptr<spk::OpenGL::BufferSetObject> _bufferSet = nullptr;
            std::unordered_map<std::wstring, Attribute> _attributes;
 
            explicit Object(Pipeline *p_owner) :
                _owner(p_owner),
                _bufferSet(nullptr),
                _attributes(_owner->_constructObjectAttributes())
            {
            }
 
        public:
            Object() = default;

            void render(GLsizei p_instanceCount = 1);

            std::shared_ptr<spk::OpenGL::BufferSetObject> &bufferSet()
            {
                return _bufferSet;
            }

            const std::shared_ptr<spk::OpenGL::BufferSetObject> &bufferSet() const
            {
                return _bufferSet;
            }

            void setBufferSet(const std::shared_ptr<spk::OpenGL::BufferSetObject> &p_bufferSet)
            {
                _bufferSet = p_bufferSet;
            }

            Attribute &attribute(const std::wstring &p_name)
            {
                return _attribute(p_name);
            }

            const Attribute &attribute(const std::wstring &p_name) const
            {
                return _attribute(p_name);
            }
 
        private:
            Attribute &_attribute(const std::wstring &p_name)
            {
                if (_attributes.contains(p_name) == false)
                {
                    throw std::runtime_error("No attribute [" + spk::StringUtils::wstringToString(p_name) + "] created in pipeline");
                }
                return _attributes.at(p_name);
            }
 
            const Attribute &_attribute(const std::wstring &p_name) const
            {
                if (_attributes.contains(p_name) == false)
                {
                    throw std::runtime_error("No attribute [" + spk::StringUtils::wstringToString(p_name) + "] created in pipeline");
                }
                return _attributes.at(p_name);
            }
        };
 
        friend class Object;
 
    private:
        struct State;
 
        static std::unordered_map<std::wstring, Constant> _constants;
        static GLuint _nextBindingPoint;
 
        std::unique_ptr<State> _state;
 
        void _ensureBlockBindingsLinked();
        void _activate();
        void _deactivate();
        void _activateConstants();
        void _deactivateConstants();
        void _render(GLsizei p_indexCount, GLsizei p_instanceCount);
 
        std::unordered_map<std::wstring, Object::Attribute> _constructObjectAttributes() const;
        spk::OpenGL::BufferSetObject _constructObjectBufferSet() const;
 
        explicit Pipeline(std::unique_ptr<State> p_state);
 
    public:
        explicit Pipeline(const std::string &p_input);
        ~Pipeline();
        Pipeline(Pipeline &&p_other) noexcept = default;
        Pipeline &operator=(Pipeline &&p_other) noexcept = default;
        Pipeline(const Pipeline &) = delete;
        Pipeline &operator=(const Pipeline &) = delete;
        static Pipeline fromFile(const std::filesystem::path &p_filePath);

        Object createObject();

        std::shared_ptr<spk::OpenGL::BufferSetObject> createBufferSet() const;

        static Constant &insertConstant(const std::string &p_jsonBlock);

        static Constant &insertConstant(const std::wstring &p_jsonBlock);

        static bool containConstant(const std::wstring &p_name);

        static Constant &constant(const std::wstring &p_name);

        static Constant &getOrCreateConstant(const std::string &p_jsonBlock);
        static Constant &getOrCreateConstant(const std::wstring &p_jsonBlock);

        spk::OpenGL::FrameBufferObject &frameBuffer(const std::wstring &p_name);
        const spk::OpenGL::FrameBufferObject &frameBuffer(const std::wstring &p_name) const;
    };
}