mesh_render_data.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2026                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_RENDER_DRAWABLE_MESH_MESH_RENDER_DATA_H
#define VCL_RENDER_DRAWABLE_MESH_MESH_RENDER_DATA_H
 
#include <vclib/render/drawable/mesh/mesh_render_info.h>
#include <vclib/render/drawable/mesh/mesh_render_settings.h>
 
#include <vclib/algorithms/mesh.h>
#include <vclib/mesh.h>
#include <vclib/space/complex.h>
 
namespace vcl {
 
template<typename MeshRenderDerived>
class MeshRenderData
{
public:
    struct TriangleMaterialChunk
    {
        uint startIndex     = 0; // start index in the triangle index buffer
        uint indexCount     = 0; // num indices in the triangle index buffer
        uint vertMaterialId = 0; // material id associated to the vertices
        uint faceMaterialId = 0; // material id associated to the faces
    };
 
private:
    using MRI = MeshRenderInfo;
 
    // Auxiliary data that can be used by the derived class to properly allocate
    // and fill the buffers
 
    uint mNumVerts       = 0;
    uint mNumTris        = 0;
    uint mNumEdges       = 0;
    uint nWireframeLines = 0;
 
    // Vector that tells, for each non-duplicated vertex, which wedges it
    // belongs to. Each pair is the face index and the vertex index in the face.
    // It allows to access the wedge texcoords for each non-duplicated vertex
    std::vector<std::pair<uint, uint>> mVertWedgeMap;
 
    // The list of vertices that has been duplicated (each element of the list
    // is the index of the vertex to duplicate)
    std::list<uint> mVertsToDuplicate;
 
    // A list that tells, for each duplicated vertex, the list of faces that
    // must be reassigned to the corresponding duplicated vertex.
    // Each duplicated vertex has a list of pairs face/vertex index in the face,
    // that must be/have been reassigned to the duplicated vertex
    std::list<std::list<std::pair<uint, uint>>> mFacesToReassign;
 
    // data used to manage the mapping beteween the original polygonal faces
    // and the triangle faces
 
    // map that stores the correspondence between the original polygonal faces
    // and the triangle faces
    TriPolyIndexBiMap mIndexMap;
 
    // bitset that tells which buffers must be filled (this value has been set
    // at construction time). It may differ from the value passed to the update
    // function, since the user may want to update only a subset of the buffers
    MRI::BuffersBitSet mBuffersToFill = MRI::BUFFERS_ALL;
 
    std::vector<TriangleMaterialChunk> mMaterialChunks;
 
public:
    void update(
        const MeshConcept auto& mesh,
        MRI::BuffersBitSet      buffersToUpdate = MRI::BUFFERS_ALL)
    {
        using enum MRI::Buffers;
 
        MRI::BuffersBitSet btu = mBuffersToFill & buffersToUpdate;
 
        // first thing to do
        updateAuxiliaryData(mesh, btu);
 
        // set data for vertices
        updateVerticesData(mesh, btu);
 
        // set data for faces
        updateFacesData(mesh, btu);
 
        // set data for edges
        updateEdgesData(mesh, btu);
 
        // set additional data for mesh
        updateMeshAdditionalData(mesh, btu);
 
        // set data for textures
        updateTextureData(mesh, btu);
    }
 
    uint triangleChunksNumber() const { return mMaterialChunks.size(); }
 
    TriangleMaterialChunk triangleChunk(uint chunkIndex) const
    {
        return mMaterialChunks[chunkIndex];
    }
 
    uint materialIndex(const MeshRenderSettings& mrs, uint chunkNumber) const
    {
        using enum MeshRenderInfo::Surface;
 
        if (mrs.isSurface(COLOR_FACE) || mrs.isSurface(COLOR_WEDGE_TEX))
            return mMaterialChunks[chunkNumber].faceMaterialId;
        else
            return mMaterialChunks[chunkNumber].vertMaterialId;
    }
 
protected:
    MeshRenderData() = default;
 
    MeshRenderData(MRI::BuffersBitSet buffersToFill) :
            mBuffersToFill(buffersToFill)
    {
    }
 
    void swap(MeshRenderData& other)
    {
        using std::swap;
        swap(mNumVerts, other.mNumVerts);
        swap(mNumTris, other.mNumTris);
        swap(mVertWedgeMap, other.mVertWedgeMap);
        swap(mVertsToDuplicate, other.mVertsToDuplicate);
        swap(mFacesToReassign, other.mFacesToReassign);
        swap(mIndexMap, other.mIndexMap);
        swap(mBuffersToFill, other.mBuffersToFill);
        swap(mMaterialChunks, other.mMaterialChunks);
    }
 
    uint numVerts() const { return mNumVerts; }
 
    uint numTris() const { return mNumTris; }
 
    uint numEdges() const { return mNumEdges; }
 
    uint numWireframeLines() const { return nWireframeLines; }
 
    // utility functions to fill the buffers
 
    void fillVertexPositions(const MeshConcept auto& mesh, auto* buffer)
    {
        vertexPositionsToBuffer(mesh, buffer);
        appendDuplicateVertexPositionsToBuffer(mesh, mVertsToDuplicate, buffer);
    }
 
    void fillVertexQuadIndices(const MeshConcept auto& mesh, auto* buffer)
    {
        vertexQuadIndicesToBuffer(mesh, buffer);
    }
 
    void fillVertexNormals(const MeshConcept auto& mesh, auto* buffer)
    {
        vertexNormalsToBuffer(mesh, buffer);
        appendDuplicateVertexNormalsToBuffer(mesh, mVertsToDuplicate, buffer);
    }
 
    void fillVertexColors(
        const MeshConcept auto& mesh,
        auto*                   buffer,
        Color::Format           fmt)
    {
        vertexColorsToBuffer(mesh, buffer, fmt);
        appendDuplicateVertexColorsToBuffer(
            mesh, mVertsToDuplicate, buffer, fmt);
    }
 
    void fillVertexTexCoords(const MeshConcept auto& mesh, auto* buffer)
    {
        vertexTexCoordsToBuffer(mesh, buffer);
        appendDuplicateVertexTexCoordsToBuffer(mesh, mVertsToDuplicate, buffer);
    }
 
    void fillVertexTangents(const MeshConcept auto& mesh, auto* buffer)
    {
        vertexTangentsToBuffer(mesh, buffer);
        appendDuplicateVertexTangentsToBuffer(mesh, mVertsToDuplicate, buffer);
    }
 
    void fillWedgeTexCoords(const FaceMeshConcept auto& mesh, auto* buffer)
    {
        wedgeTexCoordsAsDuplicatedVertexTexCoordsToBuffer(
            mesh, mVertWedgeMap, mFacesToReassign, buffer);
    }
 
    void fillTriangleIndices(const FaceMeshConcept auto& mesh, auto* buffer)
    {
        using MeshType = std::decay_t<decltype(mesh)>;
        using FaceType = MeshType::FaceType;
 
        // comparator of faces
        // ordering first by per-vertex material index (if available),
        // then by per-face material index (if available)
        auto faceComp = [&](const FaceType& f1, const FaceType& f2) {
            if constexpr (HasPerVertexMaterialIndex<MeshType>) {
                if (isPerVertexMaterialIndexAvailable(mesh)) {
                    uint id1 = f1.vertex(0)->materialIndex();
                    uint id2 = f2.vertex(0)->materialIndex();
                    if (id1 != id2) { // do not return true if equal
                        return id1 < id2;
                    }
                }
            }
            if constexpr (HasPerFaceMaterialIndex<MeshType>) {
                if (isPerFaceMaterialIndexAvailable(mesh)) {
                    uint id1 = f1.materialIndex();
                    uint id2 = f2.materialIndex();
                    if (id1 != id2) { // do not return true if equal
                        return id1 < id2;
                    }
                }
            }
 
            // if both per-vertex and per-face material indices are equal, sort
            // by face index to have a stable sorting
            return f1.index() < f2.index();
        };
 
        // get the list of face indices sorted by material ID and
        // using the face comparator defined above
        std::vector<uint> faceIndicesSortedByMaterialID =
            sortFaceIndicesByFunction(mesh, faceComp, true);
 
        triangulatedFaceVertexIndicesToBuffer(
            mesh, buffer, mIndexMap, MatrixStorageType::ROW_MAJOR, mNumTris);
        replaceTriangulatedFaceVertexIndicesByVertexDuplicationToBuffer(
            mesh, mVertsToDuplicate, mFacesToReassign, mIndexMap, buffer);
 
        // permute the triangulated face vertex indices according to the face
        // sorting by material ID (the function also edits the index map from
        // polygonal faces (which still refers to the mesh ones) to the
        // triangulated faces (which refers to the sorted triangles))
        permuteTriangulatedFaceVertexIndices(
            buffer, mIndexMap, faceIndicesSortedByMaterialID);
 
        fillChuncks(mesh);
    }
 
    void fillTriangleNormals(const FaceMeshConcept auto& mesh, auto* buffer)
    {
        triangulatedFaceNormalsToBuffer(
            mesh, buffer, mIndexMap, MatrixStorageType::ROW_MAJOR);
    }
 
    void fillTriangleColors(
        const FaceMeshConcept auto& mesh,
        auto*                       buffer,
        Color::Format               fmt)
    {
        triangulatedFaceColorsToBuffer(mesh, buffer, mIndexMap, fmt);
    }
 
    void fillVertexMaterialIndices(
        const FaceMeshConcept auto& mesh,
        auto*                       buffer)
    {
        vertexMaterialIndicesAsTriangulatedFaceMaterialIndicesToBuffer(
            mesh, buffer, mIndexMap);
    }
 
    void fillFaceMaterialIndices(const FaceMeshConcept auto& mesh, auto* buffer)
    {
        triangulatedFaceMaterialIndicesToBuffer(mesh, buffer, mIndexMap);
    }
 
    void fillEdgeIndices(const EdgeMeshConcept auto& mesh, auto* buffer)
    {
        edgeVertexIndicesToBuffer(mesh, buffer);
    }
 
    void fillEdgeNormals(const EdgeMeshConcept auto& mesh, auto* buffer)
    {
        edgeNormalsToBuffer(mesh, buffer);
    }
 
    void fillEdgeColors(
        const EdgeMeshConcept auto& mesh,
        auto*                       buffer,
        Color::Format               fmt)
    {
        edgeColorsToBuffer(mesh, buffer, fmt);
    }
 
    void fillWireframeIndices(const FaceMeshConcept auto& mesh, auto* buffer)
    {
        wireframeVertexIndicesToBuffer(mesh, buffer);
    }
 
    // functions that must be may implemented by the derived classes to set
    // the buffers:
 
    void setVertexPositionsBuffer(const MeshConcept auto&) {}
 
    void setVertexNormalsBuffer(const MeshConcept auto&) {}
 
    void setVertexColorsBuffer(const MeshConcept auto&) {}
 
    void setVertexTexCoordsBuffer(const MeshConcept auto&) {}
 
    void setVertexTangentsBuffer(const MeshConcept auto&) {}
 
    void setWedgeTexCoordsBuffer(const MeshConcept auto&) {}
 
    void setTriangleIndicesBuffer(const FaceMeshConcept auto&) {};
 
    void setTriangleNormalsBuffer(const FaceMeshConcept auto&) {}
 
    void setTriangleColorsBuffer(const FaceMeshConcept auto&) {}
 
    void setVertexMaterialIndicesBuffer(const FaceMeshConcept auto&) {}
 
    void setFaceMaterialIndicesBuffer(const FaceMeshConcept auto&) {}
 
    void setWireframeIndicesBuffer(const FaceMeshConcept auto&) {}
 
    void setEdgeIndicesBuffer(const EdgeMeshConcept auto&) {}
 
    void setEdgeNormalsBuffer(const EdgeMeshConcept auto&) {}
 
    void setEdgeColorsBuffer(const EdgeMeshConcept auto&) {}
 
    void setTextures(const MeshConcept auto&) {}
 
    void setMeshAdditionalData(const MeshConcept auto&) {}
 
private:
    MeshRenderDerived& derived()
    {
        return static_cast<MeshRenderDerived&>(*this);
    }
 
    const MeshRenderDerived& derived() const
    {
        return static_cast<const MeshRenderDerived&>(*this);
    }
 
    void updateAuxiliaryData(
        const MeshConcept auto&       mesh,
        MeshRenderInfo::BuffersBitSet btu)
    {
        using MeshType = MeshRenderDerived::MeshType;
        using enum MRI::Buffers;
 
        if (btu[toUnderlying(VERTICES)] || btu[toUnderlying(WEDGE_TEXCOORDS)] ||
            btu[toUnderlying(TRIANGLES)]) {
            mVertWedgeMap.clear();
            mVertsToDuplicate.clear();
            mFacesToReassign.clear();
 
            if constexpr (HasPerFaceWedgeTexCoords<MeshType>) {
                if (mesh.isPerFaceWedgeTexCoordsEnabled()) {
                    verticesToDuplicateByWedgeTexCoordsCount(
                        mesh,
                        mVertWedgeMap,
                        mVertsToDuplicate,
                        mFacesToReassign);
                }
            }
 
            mNumVerts = mesh.vertexCount() + mVertsToDuplicate.size();
        }
 
        if constexpr (HasFaces<MeshType>) {
            if (btu[toUnderlying(TRIANGLES)])
                mNumTris = triangulatedFaceCount(mesh);
            if (btu[toUnderlying(WIREFRAME)])
                nWireframeLines = faceVertexReferencesCount(mesh);
        }
 
        if constexpr (HasEdges<MeshType>) {
            if (btu[toUnderlying(EDGES)])
                mNumEdges = mesh.edgeCount();
        }
    }
 
    void updateVerticesData(
        const MeshConcept auto&       mesh,
        MeshRenderInfo::BuffersBitSet btu)
    {
        using MeshType = MeshRenderDerived::MeshType;
        using enum MRI::Buffers;
 
        if (btu[toUnderlying(VERTICES)]) {
            // vertex buffer (positions)
            derived().setVertexPositionsBuffer(mesh);
        }
 
        if constexpr (HasPerVertexNormal<MeshType>) {
            if (isPerVertexNormalAvailable(mesh)) {
                if (btu[toUnderlying(VERT_NORMALS)]) {
                    // vertex buffer (normals)
                    derived().setVertexNormalsBuffer(mesh);
                }
            }
        }
 
        if constexpr (HasPerVertexColor<MeshType>) {
            if (isPerVertexColorAvailable(mesh)) {
                if (btu[toUnderlying(VERT_COLORS)]) {
                    // vertex buffer (colors)
                    derived().setVertexColorsBuffer(mesh);
                }
            }
        }
 
        if constexpr (HasPerVertexTexCoord<MeshType>) {
            if (isPerVertexTexCoordAvailable(mesh)) {
                if (btu[toUnderlying(VERT_TEXCOORDS)]) {
                    // vertex buffer (UVs)
                    derived().setVertexTexCoordsBuffer(mesh);
                }
            }
        }
 
        if constexpr (HasPerVertexTangent<MeshType>) {
            if (isPerVertexTangentAvailable(mesh)) {
                if (btu[toUnderlying(VERT_TANGENT)]) {
                    // vertex buffer (tangent)
                    derived().setVertexTangentsBuffer(mesh);
                }
            }
        }
    }
 
    void updateFacesData(
        const MeshConcept auto&       mesh,
        MeshRenderInfo::BuffersBitSet btu)
    {
        using MeshType = MeshRenderDerived::MeshType;
        using enum MRI::Buffers;
 
        if constexpr (HasFaces<MeshType>) {
            if (btu[toUnderlying(TRIANGLES)]) {
                // triangle index buffer
                derived().setTriangleIndicesBuffer(mesh);
            }
 
            if constexpr (HasPerFaceWedgeTexCoords<MeshType>) {
                if (isPerFaceWedgeTexCoordsAvailable(mesh)) {
                    if (btu[toUnderlying(WEDGE_TEXCOORDS)]) {
                        // vertex wedges buffer (duplicated vertices)
                        derived().setWedgeTexCoordsBuffer(mesh);
                    }
                }
            }
 
            if constexpr (HasPerFaceNormal<MeshType>) {
                if (isPerFaceNormalAvailable(mesh)) {
                    if (btu[toUnderlying(TRI_NORMALS)]) {
                        // triangle normal buffer
                        derived().setTriangleNormalsBuffer(mesh);
                    }
                }
            }
 
            if constexpr (HasPerFaceColor<MeshType>) {
                if (isPerFaceColorAvailable(mesh)) {
                    if (btu[toUnderlying(TRI_COLORS)]) {
                        // triangle color buffer
                        derived().setTriangleColorsBuffer(mesh);
                    }
                }
            }
 
            // material indices are stored per face (each face has its own
            // material index)
            if constexpr (HasPerVertexMaterialIndex<MeshType>) {
                if (isPerVertexMaterialIndexAvailable(mesh)) {
                    if (btu[toUnderlying(VERT_TEXCOORDS)]) {
                        // triangle vertex material indices buffer
                        derived().setVertexMaterialIndicesBuffer(mesh);
                    }
                }
            }
 
            if constexpr (HasPerFaceMaterialIndex<MeshType>) {
                if (isPerFaceMaterialIndexAvailable(mesh)) {
                    if (btu[toUnderlying(WEDGE_TEXCOORDS)]) {
                        // triangle material indices buffer
                        derived().setFaceMaterialIndicesBuffer(mesh);
                    }
                }
            }
 
            if (btu[toUnderlying(WIREFRAME)]) {
                // wireframe index buffer
                derived().setWireframeIndicesBuffer(mesh);
            }
        }
    }
 
    void updateEdgesData(
        const MeshConcept auto&       mesh,
        MeshRenderInfo::BuffersBitSet btu)
    {
        using MeshType = MeshRenderDerived::MeshType;
        using enum MRI::Buffers;
 
        if constexpr (HasEdges<MeshType>) {
            if (btu[toUnderlying(EDGES)]) {
                // edge index buffer
                derived().setEdgeIndicesBuffer(mesh);
            }
 
            if constexpr (HasPerEdgeNormal<MeshType>) {
                if (isPerEdgeNormalAvailable(mesh)) {
                    if (btu[toUnderlying(EDGE_NORMALS)]) {
                        // edge normal buffer
                        derived().setEdgeNormalsBuffer(mesh);
                    }
                }
            }
 
            if constexpr (HasPerEdgeColor<MeshType>) {
                if (isPerEdgeColorAvailable(mesh)) {
                    if (btu[toUnderlying(EDGE_COLORS)]) {
                        // edge color buffer
                        derived().setEdgeColorsBuffer(mesh);
                    }
                }
            }
        }
    }
 
    void updateMeshAdditionalData(
        const MeshConcept auto&       mesh,
        MeshRenderInfo::BuffersBitSet btu)
    {
        using enum MRI::Buffers;
 
        if (btu[toUnderlying(MESH_ADDITIONAL_DATA)]) {
            // mesh additional data
            derived().setMeshAdditionalData(mesh);
        }
    }
 
    void updateTextureData(
        const MeshConcept auto&       mesh,
        MeshRenderInfo::BuffersBitSet btu)
    {
        using MeshType = MeshRenderDerived::MeshType;
        using enum MRI::Buffers;
 
        if constexpr (HasMaterials<MeshType>) {
            if (btu[toUnderlying(TEXTURES)]) {
                // textures
                derived().setTextures(mesh);
            }
        }
    }
 
    static void permuteTriangulatedFaceVertexIndices(
        auto*                    buffer,
        TriPolyIndexBiMap&       indexMap,
        const std::vector<uint>& newFaceIndices)
    {
        // newFaceIndices tells for each face, which is its new position
        // we need the inverse mapping: for each new position, which is the old
        // face index
        std::vector<uint> oldFaceIndices(newFaceIndices.size());
        for (uint i = 0; i < newFaceIndices.size(); ++i) {
            oldFaceIndices[newFaceIndices[i]] = static_cast<uint>(i);
        }
 
        // temporary copy of the buffer
        std::vector<uint> bufferCopy(indexMap.triangleCount() * 3);
 
        // temporary bimbap
        TriPolyIndexBiMap indexMapCopy;
        indexMapCopy.reserve(indexMap.triangleCount(), indexMap.polygonCount());
 
        uint copiedTriangles = 0;
 
        for (uint i = 0; i < oldFaceIndices.size(); ++i) {
            // need to place the k triangles associated to the i-th face
            // of oldFaceIndices
            uint polyIndex = oldFaceIndices[i];
            uint firstTri  = indexMap.triangleBegin(polyIndex);
            uint nTris     = indexMap.triangleCount(polyIndex);
 
            std::copy(
                buffer + firstTri * 3,
                buffer + (firstTri + nTris) * 3,
                bufferCopy.data() + copiedTriangles * 3);
 
            for (uint t = copiedTriangles; t < copiedTriangles + nTris; ++t) {
                indexMapCopy.insert(t, polyIndex);
            }
 
            copiedTriangles += nTris;
        }
 
        // copy back
        std::copy(
            bufferCopy.begin(),
            bufferCopy.begin() + copiedTriangles * 3,
            buffer);
        indexMap = std::move(indexMapCopy);
    }
 
    void fillChuncks(const FaceMeshConcept auto& mesh)
    {
        using MeshType = std::decay_t<decltype(mesh)>;
 
        mMaterialChunks.clear();
 
        uint first = 0;
        uint n     = 0;
 
        uint currentVertMatID = UINT_NULL;
        uint currentFaceMatID = UINT_NULL;
 
        for (uint i = 0; i < mIndexMap.triangleCount(); ++i) {
            uint fIndex = mIndexMap.polygon(i);
 
            if constexpr (HasPerVertexMaterialIndex<MeshType>) {
                if (isPerVertexMaterialIndexAvailable(mesh)) {
                    uint mId = mesh.face(fIndex).vertex(0)->materialIndex();
                    if (mId != currentVertMatID && n != 0) {
                        if (currentVertMatID != UINT_NULL) {
                            mMaterialChunks.push_back(
                                {first, n, currentVertMatID, currentFaceMatID});
                            first += n;
                            n = 0;
                        }
                        currentVertMatID = mId;
                    }
                }
            }
            if constexpr (HasPerFaceMaterialIndex<MeshType>) {
                if (isPerFaceMaterialIndexAvailable(mesh)) {
                    uint mId = mesh.face(fIndex).materialIndex();
                    if (mId != currentFaceMatID && n != 0) {
                        if (currentFaceMatID != UINT_NULL) {
                            mMaterialChunks.push_back(
                                {first, n, currentVertMatID, currentFaceMatID});
                            first += n;
                            n = 0;
                        }
                        currentFaceMatID = mId;
                    }
                }
            }
 
            n++;
        }
 
        mMaterialChunks.push_back(
            {first, n, currentVertMatID, currentFaceMatID});
    }
};
 
} // namespace vcl
 
#endif // VCL_RENDER_DRAWABLE_MESH_MESH_RENDER_DATA_H