mesh.h

#ifndef OE_RENDER_MESH_H
#define OE_RENDER_MESH_H
 
#include <vector>
#include <stdint.h>
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include "../util/non_copyable.h"
 
#include "../scene/vertex.h"
 
namespace oe::scene
{
    class CommonMesh;
}
 
namespace oe::render
{
    template <typename T>
    int32_t getComponentSize() noexcept
    {
        return 0;
    }
 
    // Todo put those elsewhere
    template <>
    constexpr int32_t getComponentSize<float>() noexcept
    {
        return 1;
    }
 
    template <>
    constexpr int32_t getComponentSize<glm::vec2>() noexcept
    {
        return 2;
    }
 
    template <>
    constexpr int32_t getComponentSize<glm::vec3>() noexcept
    {
        return 3;
    }
 
    template <>
    constexpr int32_t getComponentSize<glm::vec4>() noexcept
    {
        return 4;
    }
 
    template <>
    constexpr int32_t getComponentSize<glm::ivec4>() noexcept
    {
        return 4;
    }
 
    enum class MeshUsage : uint32_t
    {
        STREAM = 0x88E0,
 
        STATIC = 0x88E4,
 
        DYNAMIC = 0x88E8
    };
 
    class CommonMesh : public oe::util::NonCopyable
    {
        public:
            void renderArrays(const uint32_t count, const uint32_t offset = 0, const uint32_t mode = 0x0004);
 
            void setSubBufferData(const uint32_t size, const void* data, const uint32_t offset = 0);
 
            /*
             * Lock buffer and return buffer adress to update
             * @return pair with vertex buffer and indices buffer adress
             *
             * @note Once you finished, you must call releaseBuffer()
             */
            //void* lockBuffer(/*, const uint32_t access = WRITE_ONLY */);
 
            /*
             * Release the buffer locked
             */
            //void releaseBuffer();
 
            template <typename V>
            void bindVertexAttributes();
 
            void enableVertexAttribPointer(uint32_t index, size_t offset, size_t total, int32_t componentCount);
 
            void enableVertexAttribIPointer(uint32_t index, size_t offset, size_t total, int32_t componentCount);
 
            template <typename VertexType, typename T>
            void bindVertexAttributeToPointer(const uint32_t index, const size_t offset) noexcept
            {
                bindVertexAttributeToPointer<T>(index, offset, sizeof(VertexType));
            }
 
            template <typename ComponentType>
            void bindVertexAttributeToPointer(uint32_t index, size_t offset, size_t total) noexcept
            {
                enableVertexAttribPointer(index, offset, total, getComponentSize<ComponentType>());
            }
 
        protected:
            CommonMesh(MeshUsage usage);
 
            uint32_t _vao = 0;
            uint32_t _vbo = 0;
 
            MeshUsage _usage;
 
            void _prepare_mesh_vao(const size_t vertex_size, const size_t count, const void* data, const bool editable = false);
 
            uint32_t _prepare_mesh_ebo(const size_t size, const void* data, const bool editable = false);
 
    };
 
    class DynamicMesh : public CommonMesh
    {
        public:
            template <typename V>
            DynamicMesh(const V&, uint32_t max_count, const MeshUsage usage = MeshUsage::DYNAMIC):
                CommonMesh(usage)
            {
                _prepare_mesh_vao(sizeof(V), max_count, nullptr, true);
                bindVertexAttributes<V>();
            }
 
            template <typename V>
            DynamicMesh(const V&, uint32_t max_vertices_count, uint32_t max_indices_count, const MeshUsage usage = MeshUsage::DYNAMIC):
                CommonMesh(usage)
            {
                _prepare_mesh_vao(sizeof(V), max_vertices_count, nullptr, true);
                _indices_size = max_indices_count;
                _ebo = _prepare_mesh_ebo(max_indices_count * sizeof(oe::scene::index_t), nullptr, true);
                bindVertexAttributes<V>();
            }
 
            void render(const uint32_t offset = 0, const uint32_t mode = 0x0004);
 
            void renderElements(const uint32_t count, const uint32_t offset = 0, const uint32_t mode = 0x0004);
 
            void setIndicesData(const uint32_t size, const void* data, const uint32_t offset = 0);
 
            std::pair<void*, void*> getRawBuffers(/*, const uint32_t access = WRITE_ONLY */);
 
            void releaseRawBuffers();
 
        protected:
            uint32_t _indices_size = 0;
            uint32_t _ebo = 0;
 
    };
 
    class Mesh : public CommonMesh
    {
        public:
            template <typename M>
            Mesh(const M& mesh, const MeshUsage usage = MeshUsage::STATIC):
                CommonMesh(usage)
            {
                const std::vector<typename M::vertex_type>& vertices = mesh.getVertices();
 
                _prepare_mesh_vao(sizeof(typename M::vertex_type), vertices.size(), vertices.data());
                bindVertexAttributes<typename M::vertex_type>();
 
                for (size_t i=0; i<mesh.getSubMeshCount(); ++i)
                {
                    const std::vector<oe::scene::index_t>& indices = mesh.getIndices(i);
 
                    _ebos.push_back({_prepare_mesh_ebo(indices.size() * sizeof(oe::scene::index_t), indices.data()), indices.size()});
                }
            }
 
            ~Mesh();
 
            void render(const uint32_t sub_mesh = 0, const uint32_t mode = 0x0004, const uint32_t offset = 0);
 
        protected:
            std::vector<std::pair<uint32_t, uint32_t>> _ebos;
 
    };
}
 
#endif