spk_buffer_object.hpp

#pragma once
 
#include "structure/design_pattern/spk_activable_object.hpp"
#include "structure/design_pattern/spk_cached_data.hpp"
#include "structure/design_pattern/spk_synchronizable_object.hpp"
#include "structure/opengl/spk_opengl_includes.hpp"
#include "utils/spk_opengl_utils.hpp"
#include <cstdint>
#include <cstring>
#include <initializer_list>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace spk
{
    namespace OpenGL
    {
        class BufferObject : public spk::ActivableObject, public spk::SynchronizableObject
        {
        private:
            using SynchronizableObject::forceSynchronization;
            using SynchronizableObject::synchronize;
 
        public:
            enum class Type : GLenum
            {
                Unknow = GL_INVALID_ENUM,
                Storage = GL_ARRAY_BUFFER,
                Element = GL_ELEMENT_ARRAY_BUFFER,
                Uniform = GL_UNIFORM_BUFFER,
                Texture = GL_TEXTURE_BUFFER,
                TransformFeedback = GL_TRANSFORM_FEEDBACK_BUFFER,
                ShaderStorage = GL_SHADER_STORAGE_BUFFER,
                PixelPack = GL_PIXEL_PACK_BUFFER,
                PixelUnpack = GL_PIXEL_UNPACK_BUFFER,
                DrawIndirect = GL_DRAW_INDIRECT_BUFFER,
                AtomicCounter = GL_ATOMIC_COUNTER_BUFFER
            };

            enum class Usage : GLenum
            {
                Unknow = GL_INVALID_ENUM,
                Static = GL_STATIC_DRAW,
                Dynamic = GL_DYNAMIC_DRAW,
                Stream = GL_STREAM_DRAW,
                StaticRead = GL_STATIC_READ,
                DynamicRead = GL_DYNAMIC_READ,
                StreamRead = GL_STREAM_READ,
                StaticCopy = GL_STATIC_COPY,
                DynamicCopy = GL_DYNAMIC_COPY,
                StreamCopy = GL_STREAM_COPY
            };

            using Buffer = std::vector<uint8_t>;
 
        protected:
            Type _type;
            Usage _usage;
            spk::CachedData<GLuint> _id;

            size_t _gpuCapacity = 0;
            Buffer _content;

            void _registerCallbacks();
 
        protected:
            void _onSynchronize() override;
 
        public:
            BufferObject(const Type &p_type, const Usage &p_usage);
            BufferObject(const BufferObject &p_other);
            BufferObject &operator=(const BufferObject &p_other);

            void reserve(size_t p_size);
            void resize(size_t p_size);
            void swapData(std::vector<uint8_t> &p_data);

            template <typename TType>
            void setData(const std::vector<TType> &p_data)
            {
                static_assert(std::is_trivially_copyable_v<TType>, "BufferObject::setData requires a trivially copyable type");
 
                const size_t byteSize = p_data.size() * sizeof(TType);
                _content.resize(byteSize);
 
                if (byteSize != 0)
                {
                    std::memcpy(_content.data(), p_data.data(), byteSize);
                }
 
                requestSynchronization();
            }

            template <typename TType>
            void setData(std::initializer_list<TType> p_data)
            {
                static_assert(std::is_trivially_copyable_v<TType>, "BufferObject::setData requires a trivially copyable type");
 
                const size_t byteSize = p_data.size() * sizeof(TType);
                _content.resize(byteSize);
 
                if (byteSize != 0)
                {
                    std::memcpy(_content.data(), p_data.begin(), byteSize);
                }
 
                requestSynchronization();
            }

            void setData(const void *p_data, size_t p_size);

            void pushData(const void *p_data, size_t p_size);

            template <typename TType>
            void pushData(const TType &p_value)
            {
                static_assert(std::is_trivially_copyable_v<TType>, "BufferObject::pushData requires a trivially copyable type");
                pushData(&p_value, sizeof(TType));
            }

            template <typename TType>
            void pushData(const std::vector<TType> &p_values)
            {
                static_assert(std::is_trivially_copyable_v<TType>, "BufferObject::pushData(vector) requires a trivially copyable type");
 
                if (p_values.empty())
                {
                    return;
                }
 
                pushData(static_cast<const void *>(p_values.data()), p_values.size() * sizeof(TType));
            }

            template <typename TType>
            void pushData(std::initializer_list<TType> p_values)
            {
                static_assert(std::is_trivially_copyable_v<TType>, "BufferObject::pushData(initializer_list) requires a trivially copyable type");
 
                if (p_values.size() == 0)
                {
                    return;
                }
 
                pushData(static_cast<const void *>(p_values.begin()), p_values.size() * sizeof(TType));
            }

            void editData(const void *p_data, size_t p_offset, size_t p_size);

            template <typename TType>
            void editData(const TType &p_value, size_t p_offset)
            {
                static_assert(std::is_trivially_copyable_v<TType>, "BufferObject::editData requires a trivially copyable type");
 
                editData(static_cast<const void *>(&p_value), p_offset, sizeof(TType));
            }

            size_t size() const;

            Buffer &buffer();
            const Buffer &buffer() const;

            Buffer::value_type *data();
            const Buffer::value_type *data() const;
        };
    }
}