mesh.h

#ifndef OE_SCENE_MESH_H
#define OE_SCENE_MESH_H
 
#include <vector>
#include <glm/glm.hpp>
#include "vertex.h"
#include "aabb.h"
 
#include "../lib/mikktspace.h"
 
#include <algorithm>
#include <span>
 
namespace oe::scene
{
    struct Primitive
    {
        size_t offset;
        size_t size;
    };
 
    #if 0
    template <typename VertexType, typename IndexType = uint32_t>
    struct MeshView
    {
        std::span<VertexType> vertices;
        std::span<IndexType> indices;
    };
 
    template <typename VertexType, typename IndexType = uint32_t>
    struct ReadOnlyMeshView
    {
        std::span<const VertexType> vertices;
        std::span<const IndexType> indices;
    };
    #endif
 
    template <typename VertexType, typename IndexType>
    struct DefaultMeshSettings
    {
        using VertexContainerType = std::vector<VertexType>;
        using IndexContainerType = std::vector<IndexType>;
 
        using PrimitivesContainerType = std::vector<Primitive>;
    };
 
    template <typename VertexType = Vertex, typename IndexType = uint32_t, typename MeshSettingsType = DefaultMeshSettings<VertexType, IndexType>>
    struct Mesh
    {
        using vertex_type = VertexType;
        using index_type = IndexType;
 
        using VertexContainerType = MeshSettingsType::VertexContainerType;
        using IndexContainerType = MeshSettingsType::IndexContainerType;
 
        VertexContainerType vertices;
        IndexContainerType indices;
 
        MeshSettingsType::PrimitivesContainerType primitives = {};
 
        template <typename PrimitiveType>
        static Mesh generateFromPrimitives(std::span<const PrimitiveType> primitives)
        {
            Mesh result;
 
            // Get total vertices and indices sizes + Fill primitives data (indice offsets + sizes)
            size_t total_vertices_count = 0;
            size_t total_indices_count = 0;
 
            result.primitives.reserve(primitives.size());
 
            for (const auto &it : primitives)
            {
                result.primitives.emplace_back(total_indices_count, it.indices.size());
 
                total_vertices_count += it.vertices.size();
                total_indices_count += it.indices.size();
            }
 
            // Reserve mesh data and fill them
            result.vertices.reserve(total_vertices_count);
            result.indices.reserve(total_indices_count);
 
            size_t vertices_count = 0;
            for (const auto &it : primitives)
            {
                const auto& vertices = it.vertices;
                const auto& indices = it.indices;
 
                // Append vertices (copy as-is)
                result.vertices.insert(result.vertices.end(), vertices.cbegin(), vertices.cend());
 
                // Append indices (add vertices offset to make them work)
                std::ranges::transform(
                    indices,
                    std::back_inserter(result.indices),
                    [vertices_count](const IndexType& i) { return vertices_count + i; }
                );
 
                // Update vertices count inserted so far (used as indices offset)
                vertices_count += vertices.size();
            }
 
            return result;
        }
 
        constexpr AABB getPrimitiveBoundingBox(size_t primitive) const noexcept
        {
            assert(primitive < primitives.size());
 
            const auto& primitive_data = primitives.at(primitive);
 
            std::span<index_type> primitive_indices = {indices.begin() + primitive_data.offset, primitive_data.size};
 
            AABB result;
            bool is_first_vertex = true;
 
            for (auto &it : primitive_indices)
            {
                const vertex_type& vertex = vertices.at(it);
 
                if (is_first_vertex)
                {
                    result = {vertex.position, vertex.position};
                    is_first_vertex = false;
                }
                else
                {
                    result.extendToPoint(vertex.position);
                }
            }
 
            return result;
        }
 
        template <typename F>
        constexpr AABB getPrimitiveBoundingBox(size_t primitive, F&& predicate) const noexcept
        {
            assert(primitive < primitives.size());
 
            const auto& primitive_data = primitives.at(primitive);
 
            std::span<index_type> primitive_indices = {indices.begin() + primitive_data.offset, primitive_data.size};
 
            AABB result;
            bool is_first_vertex = true;
 
            for (auto &it : primitive_indices)
            {
                const vertex_type& vertex = vertices.at(it);
 
                if (predicate(vertex))
                {
                    if (is_first_vertex)
                    {
                        result = {vertex.position, vertex.position};
                        is_first_vertex = false;
                    }
                    else
                    {
                        result.extendToPoint(vertex.position);
                    }
                }
            }
 
            return result;
        }
 
        constexpr AABB getBoundingBox() const noexcept
        {
            AABB result;
            bool is_first_vertex = true;
 
            for (auto &vertex : vertices)
            {
                if (is_first_vertex)
                {
                    result = {vertex.position, vertex.position};
                    is_first_vertex = false;
                }
                else
                {
                    result.extendToPoint(vertex.position);
                }
            }
 
            return result;
        }
 
        constexpr void flipFaces()
        {
            for (size_t i=0; i<indices.size(); i+=3)
            {
                std::swap(indices[i+2], indices[i+0]);
            }
        }
 
        constexpr const std::vector<glm::uvec3> getTriangles() const
        {
            std::vector<glm::uvec3> result;
 
            result.reserve(indices.size());
 
            for (size_t i=0; i<indices.size(); i += 3)
            {
                result.emplace_back(
                    indices[i],
                    indices[i + 1],
                    indices[i + 2]
                );
            }
 
            return result;
        }
 
        /*
         * @brief Get groups of 3 indices that form triangles
         */
        /*constexpr const std::vector<glm::uvec3> getTriangles(uint32_t sub_mesh) const
        {
            std::vector<glm::uvec3> result;
 
            result.reserve(indices.size());
 
            for (size_t i=0; i<indices.size(); i += 3)
            {
                result.emplace_back(
                    indices[i],
                    indices[i + 1],
                    indices[i + 2]
                );
            }
 
            return result;
        }*/
 
        constexpr void generateNormals()
        {
            std::vector<glm::uvec3> triangles = getTriangles();
 
            if (triangles.size() == 0)
                return;
 
            // Triangle edges vectors + normal
            glm::vec3 e1, e2, no;
 
            std::vector<size_t> count_normals;
            count_normals.resize(vertices.size());
 
            for (size_t i=0; i<vertices.size(); i++)
            {
                vertices[i].normal = glm::vec3(0.0);
            }
 
            for (size_t i=0; i<triangles.size(); i++)
            {
                const glm::uvec3& face = triangles[i];
 
                VertexType& va = vertices[face[0]];
                VertexType& vb = vertices[face[1]];
                VertexType& vc = vertices[face[2]];
 
                e1 = vb.position - va.position;
                e2 = vc.position - va.position;
 
                no = glm::cross(e1, e2);
 
                va.normal += no;
                vb.normal += no;
                vc.normal += no;
 
                count_normals[face[0]]++;
                count_normals[face[1]]++;
                count_normals[face[2]]++;
            }
 
            for (size_t i=0; i<vertices.size(); i++)
            {
                if (count_normals[i] > 0)
                {
                    vertices[i].normal = glm::normalize(vertices[i].normal / (float)count_normals[i]);
                }
            }
        }
 
        struct MikkTSpaceUserData
        {
            Mesh* mesh;
 
            std::vector<glm::uvec3> triangles;
        };
 
        constexpr void generateTangents()
        {
            SMikkTSpaceInterface callbacks
            {
                .m_getNumFaces = [] (const SMikkTSpaceContext * pContext) -> int
                {
                    // Tell MikkTSpace how many faces (ie triangles) the mesh have
                    const MikkTSpaceUserData* data = static_cast<MikkTSpaceUserData*>(pContext->m_pUserData);
                    const std::vector<glm::uvec3>& triangles = data->triangles;
 
                    return triangles.size();
                },
 
                .m_getNumVerticesOfFace = [] (const SMikkTSpaceContext*, const int32_t) -> int32_t
                {
                    // We always deal with triangles
                    return 3;
                },
 
                .m_getPosition = [] (const SMikkTSpaceContext * pContext, float fvPosOut[], const int32_t iFace, const int32_t iVert)
                {
                    // Tell MikkTSpace how to get a vertex position from face + vertex ids
                    const MikkTSpaceUserData* data = static_cast<MikkTSpaceUserData*>(pContext->m_pUserData);
                    const Mesh* mesh = data->mesh;
                    const std::vector<glm::uvec3>& triangles = data->triangles;
 
                    const std::vector<VertexType>& vertices = mesh->vertices;
 
                    const VertexType& vertex = vertices[triangles[iFace][iVert]];
                    const glm::vec3& position = vertex.position;
 
                    fvPosOut[0] = position.x;
                    fvPosOut[1] = position.y;
                    fvPosOut[2] = position.z;
                },
 
                .m_getNormal = [] (const SMikkTSpaceContext * pContext, float fvNormOut[], const int32_t iFace, const int32_t iVert)
                {
                    // Tell MikkTSpace how to get a vertex normal from face + vertex ids
                    const MikkTSpaceUserData* data = static_cast<MikkTSpaceUserData*>(pContext->m_pUserData);
                    const Mesh* mesh = data->mesh;
                    const std::vector<glm::uvec3>& triangles = data->triangles;
 
                    const std::vector<VertexType>& vertices = mesh->vertices;
 
                    const VertexType& vertex = vertices[triangles[iFace][iVert]];
                    const glm::vec3& normal = vertex.normal;
 
                    fvNormOut[0] = normal.x;
                    fvNormOut[1] = normal.y;
                    fvNormOut[2] = normal.z;
                },
 
                .m_getTexCoord = [] (const SMikkTSpaceContext * pContext, float fvTexcOut[], const int32_t iFace, const int32_t iVert)
                {
                    // Tell MikkTSpace how to get a vertex texture coordinate from face + vertex ids
                    const MikkTSpaceUserData* data = static_cast<MikkTSpaceUserData*>(pContext->m_pUserData);
                    const Mesh* mesh = data->mesh;
                    const std::vector<glm::uvec3>& triangles = data->triangles;
 
                    const std::vector<VertexType>& vertices = mesh->vertices;
 
                    const VertexType& vertex = vertices[triangles[iFace][iVert]];
                    const glm::vec2& tex_coords = vertex.tex_coords_0;
 
                    fvTexcOut[0] = tex_coords.x;
                    fvTexcOut[1] = tex_coords.y;
                },
 
                .m_setTSpaceBasic = [] (const SMikkTSpaceContext * pContext, const float fvTangent[], const float fSign, const int32_t iFace, const int32_t iVert)
                {
                    // Tell MikkTSpace how to set a vertex tangent values (tangent + bitangent) face + vertex ids
                    const MikkTSpaceUserData* data = static_cast<MikkTSpaceUserData*>(pContext->m_pUserData);
                    Mesh* mesh = data->mesh;
                    const std::vector<glm::uvec3>& triangles = data->triangles;
 
                    std::vector<VertexType>& vertices = mesh->vertices;
 
                    VertexType& vertex = vertices[triangles[iFace][iVert]];
 
                    vertex.tangent = glm::vec3(fvTangent[0], fvTangent[1], fvTangent[2]);
                    vertex.bitangent = fSign * glm::cross(vertex.tangent, vertex.normal);
                },
 
                .m_setTSpace = [] (const SMikkTSpaceContext *, const float[], const float[], const float , const float, const tbool, const int32_t, const int32_t)
                {
                    // Not used, "basic" tangent space is sufficient for our use-case
                }
            };
 
            // Init user data, the real magic here is getTriangles which is computed once and cached here instead of each time
            MikkTSpaceUserData user_data = {
                .mesh = this,
                .triangles = getTriangles()
            };
 
            SMikkTSpaceContext context = {
                .m_pInterface = &callbacks,
                .m_pUserData = &user_data
            };
 
            genTangSpaceDefault(&context);
        }
    };
 
    using SolidMesh = Mesh<Vertex>;
    using SkinnedMesh = Mesh<SkinnedVertex>;
}
 
#endif