spk_vertex_buffer_object.hpp

#pragma once
 
#include "structure/design_pattern/spk_synchronizable_object.hpp"
#include "structure/opengl/spk_buffer_object.hpp"
#include "structure/opengl/spk_opengl_includes.hpp"
#include <cstdint>
#include <cstring>
#include <initializer_list>
#include <span>
#include <stdexcept>
#include <type_traits>
#include <vector>
 
namespace spk
{
    namespace OpenGL
    {
        class VertexBufferObject : public OpenGL::BufferObject
        {
        public:
            class Layout : public spk::SynchronizableObject
            {
            public:
                struct Attribute
                {
                    using Index = GLuint;

                    enum class Type
                    {
                        None,
                        Float,
                        Bool,
                        Int,
                        UInt,
                        Vector2,
                        Vector3,
                        Vector4,
                        Color,
                        Vector2Int,
                        Vector3Int,
                        Vector4Int,
                        Vector2UInt,
                        Vector3UInt,
                        Vector4UInt,
                        Matrix2x2,
                        Matrix3x3,
                        Matrix4x4
                    };

                    Index index;
                    Type type;
                };
 
            private:
                friend class VertexBufferObject;
 
                std::vector<Attribute> _attributes;
                size_t _stride = 0;
                const VertexBufferObject *_owner;
 
                struct AttributeFormat
                {
                    GLint componentCount;
                    GLenum glType;
                    bool integer;
                };
 
                static size_t _attributeTypeSize(Attribute::Type p_type);
                static AttributeFormat _attributeFormat(Attribute::Type p_type);
                static size_t _computeStride(const std::vector<Attribute> &p_attributes);
 
                void _configureAttributes();
                void _onSynchronize() override;
 
            public:
                explicit Layout(const VertexBufferObject *p_owner);

                void addAttribute(Attribute p_attribute);

                const std::vector<Attribute> &attributes() const;
                size_t stride() const;
            };
 
        private:
            using BufferObject::data;
            using BufferObject::editData;
            using BufferObject::pushData;
            using BufferObject::reserve;
            using BufferObject::resize;
            using BufferObject::setData;
            using BufferObject::size;
            using BufferObject::swapData;
 
            Layout _layout;
 
        private:
            void _ensureStrideForLayout(size_t p_vertexSize);
 
        protected:
            void _onSynchronize() override;

            void _ensureStrideForRead(size_t p_vertexSize) const;
 
        public:
            VertexBufferObject(Usage p_usage);
            VertexBufferObject(const VertexBufferObject &p_other);
            VertexBufferObject &operator=(const VertexBufferObject &p_other);

            Layout &layout();
            const Layout &layout() const;

            size_t vertexCount() const;
 
            template <typename TVertex>
            std::vector<TVertex> pull() const
            {
                static_assert(std::is_trivially_copyable_v<TVertex>, "VertexBufferObject requires trivially copyable vertex types");
 
                _ensureStrideForRead(sizeof(TVertex));
 
                const auto rawData = spk::OpenGLUtils::readBuffer(static_cast<GLenum>(_type), static_cast<GLuint>(_id));
                if (rawData.empty())
                {
                    return {};
                }
 
                if (rawData.size() % sizeof(TVertex) != 0)
                {
                    throw std::runtime_error("VertexBufferObject::pull: GPU buffer size is not a multiple of TVertex");
                }
 
                std::vector<TVertex> vertices(rawData.size() / sizeof(TVertex));
                std::memcpy(vertices.data(), rawData.data(), rawData.size());
                return vertices;
            }
 
            template <typename TVertex>
            void setVertices(const std::vector<TVertex> &p_vertices)
            {
                static_assert(std::is_trivially_copyable_v<TVertex>, "VertexBufferObject requires trivially copyable vertex types");
 
                _ensureStrideForLayout(sizeof(TVertex));
                BufferObject::setData(p_vertices);
            }
 
            template <typename TVertex>
            void setVertices(std::initializer_list<TVertex> p_vertices)
            {
                static_assert(std::is_trivially_copyable_v<TVertex>, "VertexBufferObject requires trivially copyable vertex types");
 
                _ensureStrideForLayout(sizeof(TVertex));
                BufferObject::setData(p_vertices);
            }
 
            template <typename TVertex>
            void pushVertex(const TVertex &p_vertex)
            {
                static_assert(std::is_trivially_copyable_v<TVertex>, "VertexBufferObject requires trivially copyable vertex types");
 
                _ensureStrideForLayout(sizeof(TVertex));
                BufferObject::pushData(p_vertex);
            }
 
            template <typename TVertex>
            void pushVertices(const std::vector<TVertex> &p_vertices)
            {
                static_assert(std::is_trivially_copyable_v<TVertex>, "VertexBufferObject requires trivially copyable vertex types");
 
                if (p_vertices.empty())
                {
                    return;
                }
 
                _ensureStrideForLayout(sizeof(TVertex));
                BufferObject::pushData(p_vertices);
            }
 
            template <typename TVertex>
            void pushVertices(std::initializer_list<TVertex> p_vertices)
            {
                static_assert(std::is_trivially_copyable_v<TVertex>, "VertexBufferObject requires trivially copyable vertex types");
 
                if (p_vertices.size() == 0)
                {
                    return;
                }
 
                _ensureStrideForLayout(sizeof(TVertex));
                BufferObject::pushData(p_vertices);
            }
 
            template <typename TVertex>
            std::span<TVertex> vertices()
            {
                _ensureStrideForRead(sizeof(TVertex));
                return {reinterpret_cast<TVertex *>(BufferObject::data()), vertexCount()};
            }
 
            template <typename TVertex>
            std::span<const TVertex> vertices() const
            {
                _ensureStrideForRead(sizeof(TVertex));
                return {reinterpret_cast<const TVertex *>(BufferObject::data()), vertexCount()};
            }
        };
 
        using VBO = VertexBufferObject;
    }
}