mesh.h

#ifndef OE_RENDER_MESH_H
#define OE_RENDER_MESH_H
 
#include <glue_chan/glue_chan.h>
#include <vector>
 
#include "../scene/mesh.h"
#include "../core/renderer/opengl.h"
 
namespace oe::render
{
    struct VertexAttributes
    {
        uint32_t& vertex_array;

        template <typename V>
        void bindVertexAttributes();
 
        void enableVertexAttribPointer(const uint32_t index, const size_t offset, const int32_t componentCount)
        {
            // Hardcode float because this function is only used for glVertexAttribPointer
            glEnableVertexArrayAttrib(vertex_array, index);
            glVertexArrayAttribFormat(vertex_array, index, componentCount, GL_FLOAT, false, offset);
            glVertexArrayAttribBinding(vertex_array, index, 0);
        }
 
        void enableVertexAttribIPointer(const uint32_t index, const size_t offset, const int32_t componentCount)
        {
            // Hardcode int because this function is only used for glVertexAttribIPointer
            glEnableVertexArrayAttrib(vertex_array, index);
            glVertexArrayAttribIFormat(vertex_array, index, componentCount, GL_INT, offset);
            glVertexArrayAttribBinding(vertex_array, index, 0);
        }

        template <typename T>
        int32_t getComponentSize() noexcept;

        template <typename VertexType, typename T>
        void bindVertexAttributeToPointer(const uint32_t index, const size_t offset) noexcept
        {
            enableVertexAttribPointer(index, offset, getComponentSize<T>());
        }

        template <typename VertexType, typename T>
        void bindVertexAttributeToIPointer(const uint32_t index, const size_t offset) noexcept
        {
            enableVertexAttribIPointer(index, offset, getComponentSize<T>());
        }
    };

    constexpr const uint8_t default_mesh_rendering_mode = 0x04;
 
    class Mesh
    {
        public:
            template <typename SceneMeshType>
            Mesh(const SceneMeshType& scene_mesh, bool editable = false):
                primitives(scene_mesh.primitives),
                _index_size(sizeof(typename SceneMeshType::index_type))
            {
                assert(oe::core::OpenGL::hasContext());
 
                const auto& vertices = scene_mesh.vertices;
                const auto& indices = scene_mesh.indices;
 
                _common_construct<SceneMeshType>(
                    vertices.size(), vertices.data(),
                    indices.size(), indices.data(),
                    editable
                );
            }

            template <typename SceneMeshType>
            Mesh(const SceneMeshType&, uint32_t max_vertices_count, uint32_t max_indices_count):
                _index_size(sizeof(typename SceneMeshType::index_type))
            {
                assert(oe::core::OpenGL::hasContext());
 
                _common_construct<SceneMeshType>(
                    max_vertices_count, nullptr,
                    max_indices_count, nullptr,
                    true
                );
            }
 
            Mesh(const Mesh&) = delete;
            Mesh& operator=(const Mesh&) = delete;
 
            Mesh(Mesh&& other) noexcept:
                primitives(other.primitives),
                _index_type(other._index_type),
                _index_size(other._index_size),
                _vao(other._vao),
                _vbo(other._vbo),
                _ebo(other._ebo)
            {
                other._vao = 0;
                other._vbo = 0;
                other._ebo = 0;
            }
 
            ~Mesh()
            {
                if (_vao != 0)
                {
                    const uint32_t buffers[2] = {_vbo, _ebo};
                    glDeleteBuffers(2, buffers);
 
                    glDeleteVertexArrays(1, &_vao);
                }
            }

            void setSubBufferData(const uint32_t size, const void* data, const uint32_t offset = 0)
            {
                glNamedBufferSubData(_vbo, offset, size, data);
            }

            void setIndicesData(const uint32_t size, const void* data, const uint32_t offset = 0)
            {
                glNamedBufferSubData(_ebo, offset, size, data);
            }

            std::pair<void*, void*> getRawBuffers()
            {
                glBindVertexArray(_vao);
 
                return
                {
                    glMapNamedBuffer(_vbo, GL_WRITE_ONLY),
                    glMapNamedBuffer(_ebo, GL_WRITE_ONLY)
                };
            }

            void releaseRawBuffers()
            {
                glUnmapNamedBuffer(_vbo);
                glUnmapNamedBuffer(_ebo);
            }

            void renderArrays(const uint32_t count, const uint32_t offset, uint32_t mode)
            {
                glBindVertexArray(_vao);
                glDrawArrays(mode, offset, count);
            }

            void renderElements(const uint32_t count, const uint32_t offset, const uint32_t mode)
            {
                glBindVertexArray(_vao);
                glDrawElements(mode, count, GL_UNSIGNED_INT, reinterpret_cast<uint32_t*>(offset));
            }

            void render(const std::vector<bool>& activeprimitives, uint32_t mode = default_mesh_rendering_mode)
            {
                assert(primitives.size() && "If this triggers, you forgot to add primitives to mesh, maybe you meant to renderArrays instead?");
                assert(activeprimitives.size() == primitives.size());
 
                // Compute offsets based on "jumps" in submeshes list
                std::vector<oe::scene::Primitive> primitive_render_calls;
 
                oe::scene::Primitive current_packed_primitive = {0, 0};
                bool last_primitive_active = false;
                size_t i = 0;
 
                for (const auto& is_active : activeprimitives)
                {
                    const auto& primitive_data = primitives.at(i);
 
                    if (last_primitive_active)
                    {
                        if (is_active)
                        {
                            current_packed_primitive.size += primitive_data.size;
                        }
                        else
                        {
                            primitive_render_calls.push_back(current_packed_primitive);
 
                            current_packed_primitive.offset = 0;
                            current_packed_primitive.size = 0;
                        }
                    }
                    else
                    {
                        if (is_active)
                        {
                            current_packed_primitive.offset = primitive_data.offset;
                            current_packed_primitive.size = primitive_data.size;
                        }
                    }
 
                    last_primitive_active = is_active;
 
                    ++i;
                }
 
                if (last_primitive_active)
                {
                    // Append the last primitive
                    primitive_render_calls.push_back(current_packed_primitive);
                }
 
                glBindVertexArray(_vao);
 
                for (const auto& it : primitive_render_calls)
                {
                    glDrawElements(mode, it.size, _index_type, reinterpret_cast<void*>(it.offset * _index_size));
                }
            }

            void renderAll(uint32_t mode = default_mesh_rendering_mode)
            {
                assert(primitives.size() && "If this triggers, you forgot to add primitives to mesh, maybe you meant to renderArrays instead?");
 
                glBindVertexArray(_vao);
 
                size_t total_size = 0;
 
                for (const auto& it : primitives)
                {
                    total_size += it.size;
                }
 
                glDrawElements(mode, total_size, _index_type, nullptr);
            }

            std::vector<oe::scene::Primitive> primitives;
 
        private:
            uint32_t _index_type = 0;
            uint8_t _index_size = 0;
 
            uint32_t _vao;
            uint32_t _vbo;
            uint32_t _ebo;
 
            template <typename SceneMeshType>
            void _common_construct(
                const size_t vertices_count, const void* vertices_data,
                const size_t indices_count, const void* indices_data,
                const bool editable)
            {
                _index_type = (_index_size == 1) ? GL_UNSIGNED_BYTE
                    : (_index_size == 2) ? GL_UNSIGNED_SHORT
                    : GL_UNSIGNED_INT
                ;
 
                glCreateVertexArrays(1, &_vao);
 
                std::array<uint32_t, 2> buffers;
 
                glCreateBuffers(2, buffers.data());
 
                _vbo = buffers[0];
                _ebo = buffers[1];
 
                VertexAttributes vertex_attributes(_vao);
                vertex_attributes.bindVertexAttributes<typename SceneMeshType::vertex_type>();
 
                size_t vertex_size = sizeof(typename SceneMeshType::vertex_type);
 
                if (editable)
                {
                    glNamedBufferStorage(_vbo, vertex_size * vertices_count, vertices_data, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT);
                    glNamedBufferStorage(_ebo, _index_size * indices_count, indices_data, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT);
                }
                else
                {
                    glNamedBufferStorage(_vbo, vertex_size * vertices_count, vertices_data, 0);
                    glNamedBufferStorage(_ebo, _index_size * indices_count, indices_data, 0);
                }
 
                glVertexArrayVertexBuffer(_vao, 0, _vbo, 0, vertex_size);
                glVertexArrayElementBuffer(_vao, _ebo);
            }
    };
}
 
#include "mesh.inl"
 
#endif