mesh.h

#ifndef OE_SCENE_MESH_H
#define OE_SCENE_MESH_H
 
#include "../common.h"
 
#include <vector>
#include <glm/glm.hpp>
#include <functional>
#include "vertex.h"
#include "aabb.h"
 
#include "../lib/mikktspace.h"
 
namespace oe::scene
{
    template<class F, class V>
    concept VertexPredicateFunction = requires(F f, V v)
    {
        {f(v)} -> std::same_as<bool>;
    };
 
    class CommonMesh
    {
        public:
            constexpr uint32_t getSubMeshCount() const noexcept
            {
                return _indices.size();
            }
 
            constexpr const std::vector<index_t>& getIndices(uint32_t sub_mesh = 0) const noexcept
            {
                return _indices[sub_mesh];
            }
 
            constexpr const AABB& getBoundingBox() const noexcept
            {
                return _aabb;
            }
 
            constexpr void flipFaces() noexcept
            {
                for (auto& submesh : _indices)
                {
                    for (size_t i=0; i<submesh.size(); i+=3)
                    {
                        std::swap(submesh[i+2], submesh[i+0]);
                    }
                }
            }
 
            constexpr const std::vector<glm::uvec3> getTriangles(uint32_t sub_mesh = 0) const
            {
                const std::vector<index_t>& indices = _indices.at(sub_mesh);
 
                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;
            }
 
        protected:
            std::vector<std::vector<index_t>> _indices;
 
            AABB _aabb;
    };
 
    template <SimpleVertex V>
    class SimpleMesh : public CommonMesh
    {
        public:
            using vertex_type = V;
 
            SimpleMesh(const std::vector<V>& vertices, const std::vector<index_t>& indices = {}):
                _vertices(vertices)
            {
                if (indices.size() > 0)
                    addSubMesh(indices);
            }
 
            SimpleMesh(const std::vector<V>& vertices, const std::vector<std::vector<index_t>>& mesh_indices):
                _vertices(vertices)
            {
                for (auto& submesh : mesh_indices)
                {
                    addSubMesh(submesh);
                }
            }
 
            constexpr uint32_t addSubMesh(const std::vector<oe::scene::index_t>& indices) noexcept
            {
                _indices.push_back(indices);
 
                // BBox is empty, init with first vertex
                if (_aabb.isEmpty())
                    _aabb = {_vertices[indices[0]].position, _vertices[indices[0]].position};
 
                for (auto& id_vertex : indices)
                {
                    _aabb.extendToPoint(_vertices[id_vertex].position);
                }
 
                return _indices.size() -1;
            }
 
            constexpr std::vector<V>& getVertices() noexcept
            {
                return _vertices;
            }
 
            constexpr const std::vector<V>& getVertices() const noexcept
            {
                return _vertices;
            }
 
            template <VertexPredicateFunction<V> F>
            constexpr AABB generateBoundingBoxFromPredicate(F&& predicate) const noexcept
            {
                const auto& vertices = _vertices;
 
                AABB result;
                bool is_first_vertex = true;
 
                for (auto& it : vertices)
                {
                    if (predicate(it))
                    {
                        if (is_first_vertex)
                        {
                            result = {it.position, it.position};
                            is_first_vertex = false;
                        }
                        else
                        {
                            result.extendToPoint(it.position);
                        }
                    }
                }
 
                return result;
            }
 
        protected:
            SimpleMesh() {}
 
            std::vector<V> _vertices;
    };
 
    void computeTangentsFromMikkTSpace(const SMikkTSpaceContext& context);
 
    template <ComplexVertex V>
    class ComplexMesh : public SimpleMesh<V>
    {
        public:
            // Seamlessly use parent constructors
            using SimpleMesh<V>::SimpleMesh;
 
            constexpr void generateSmoothNormals(uint32_t sub_mesh = 0)
            {
                std::vector<glm::uvec3> triangles = CommonMesh::getTriangles(sub_mesh);
                std::vector<V>& vertices = SimpleMesh<V>::_vertices;
 
                if (triangles.size() == 0)
                    return;
 
                // Triangle edges vectors + normal
                glm::vec3 e1, e2, no;
 
                std::vector<size_t> count_normals;
 
                for (size_t i=0; i<vertices.size(); i++)
                {
                    vertices[i].normal = glm::vec3(0.0);
                    count_normals.push_back(0);
                }
 
                for (size_t i=0; i<triangles.size(); i++)
                {
                    const glm::uvec3& face = triangles[i];
 
                    V& va = vertices[face[0]];
                    V& vb = vertices[face[1]];
                    V& 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
            {
                ComplexMesh* 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 int) -> int
                    {
                        // We always deal with triangles
                        return 3;
                    },
 
                    .m_getPosition = [] (const SMikkTSpaceContext * pContext, float fvPosOut[], const int iFace, const int iVert)
                    {
                        // Tell MikkTSpace how to get a vertex position from face + vertex ids
                        const MikkTSpaceUserData* data = static_cast<MikkTSpaceUserData*>(pContext->m_pUserData);
                        const ComplexMesh<V>* mesh = data->mesh;
                        const std::vector<glm::uvec3>& triangles = data->triangles;
 
                        const std::vector<V>& vertices = mesh->getVertices();
 
                        const V& 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 int iFace, const int iVert)
                    {
                        // Tell MikkTSpace how to get a vertex normal from face + vertex ids
                        const MikkTSpaceUserData* data = static_cast<MikkTSpaceUserData*>(pContext->m_pUserData);
                        const ComplexMesh<V>* mesh = data->mesh;
                        const std::vector<glm::uvec3>& triangles = data->triangles;
 
                        const std::vector<V>& vertices = mesh->getVertices();
 
                        const V& 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 int iFace, const int iVert)
                    {
                        // Tell MikkTSpace how to get a vertex texture coordinate from face + vertex ids
                        const MikkTSpaceUserData* data = static_cast<MikkTSpaceUserData*>(pContext->m_pUserData);
                        const ComplexMesh<V>* mesh = data->mesh;
                        const std::vector<glm::uvec3>& triangles = data->triangles;
 
                        const std::vector<V>& vertices = mesh->getVertices();
 
                        const V& vertex = vertices[triangles[iFace][iVert]];
                        const glm::vec2& tex_coords = vertex.tex_coords;
 
                        fvTexcOut[0] = tex_coords.x;
                        fvTexcOut[1] = tex_coords.y;
                    },
 
                    .m_setTSpaceBasic = [] (const SMikkTSpaceContext * pContext, const float fvTangent[], const float fSign, const int iFace, const int iVert)
                    {
                        // Tell MikkTSpace how to set a vertex tangent values (tangent + bitangent) face + vertex ids
                        const MikkTSpaceUserData* data = static_cast<MikkTSpaceUserData*>(pContext->m_pUserData);
                        ComplexMesh<V>* mesh = data->mesh;
                        const std::vector<glm::uvec3>& triangles = data->triangles;
 
                        std::vector<V>& vertices = mesh->getVertices();
 
                        V& vertex = vertices[triangles[iFace][iVert]];
 
                        vertex.tangent = glm::vec3(fvTangent[0], fvTangent[1], fvTangent[2]);
                        vertex.bitangent = fSign * glm::cross(vertex.normal, vertex.tangent);
                    },
 
                    .m_setTSpace = [] (const SMikkTSpaceContext *, const float[], const float[], const float , const float, const tbool , const int , const int )
                    {
                        // 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 = CommonMesh::getTriangles()
                };
 
                computeTangentsFromMikkTSpace({
                    .m_pInterface = &callbacks,
                    .m_pUserData = &user_data
                });
            }
 
            constexpr void generateTexcoords()
            {
                std::vector<V>& vertices = SimpleMesh<V>::_vertices;
 
                for (size_t i=0; i<vertices.size(); i++)
                {
                    V& vertex = vertices[i];
                    vertex.tex_coords = glm::vec2(vertex.position.x, vertex.position.y);
                }
            }
    };
 
    using Mesh = ComplexMesh<Vertex>;
    using SkinnedMesh = ComplexMesh<SkinnedVertex>;
}
 
#endif