mesh_render_data.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * 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/algorithms/mesh/import_export/append_replace_to_buffer.h>
#include <vclib/algorithms/mesh/import_export/export_buffer.h>
#include <vclib/algorithms/mesh/stat/topology.h>
#include <vclib/mesh/requirements.h>
#include <vclib/render/drawable/mesh/mesh_render_info.h>
#include <vclib/space/complex/tri_poly_index_bimap.h>
 
namespace vcl {
 
template<typename MeshRenderDerived>
class MeshRenderData
{
    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;
 
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 data for mesh
        updateMeshData(mesh, btu);
 
        // set data for textures
        updateTextureData(mesh, btu);
    }
 
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);
    }
 
    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 fillWedgeTexCoords(const FaceMeshConcept auto& mesh, auto* buffer)
    {
        wedgeTexCoordsAsDuplicatedVertexTexCoordsToBuffer(
            mesh, mVertWedgeMap, mFacesToReassign, buffer);
    }
 
    void fillTriangleIndices(const FaceMeshConcept auto& mesh, auto* buffer)
    {
        triangulatedFaceIndicesToBuffer(
            mesh, buffer, mIndexMap, MatrixStorageType::ROW_MAJOR, mNumTris);
        replaceTriangulatedFaceIndicesByVertexDuplicationToBuffer(
            mesh, mVertsToDuplicate, mFacesToReassign, mIndexMap, buffer);
    }
 
    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 fillVertexTextureIndices(
        const FaceMeshConcept auto& mesh,
        auto*                       buffer)
    {
        vertexTexCoordIndicesAsTriangulatedFaceTexCoordIndicesToBuffer(
            mesh, buffer, mIndexMap);
    }
 
    void fillWedgeTextureIndices(const FaceMeshConcept auto& mesh, auto* buffer)
    {
        triangulatedFaceWedgeTexCoordIndicesToBuffer(mesh, buffer, mIndexMap);
    }
 
    void fillEdgeIndices(const EdgeMeshConcept auto& mesh, auto* buffer)
    {
        edgeIndicesToBuffer(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)
    {
        wireframeIndicesToBuffer(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 setWedgeTexCoordsBuffer(const MeshConcept auto&) {}
 
    void setTriangleIndicesBuffer(const FaceMeshConcept auto&) {};
 
    void setTriangleNormalsBuffer(const FaceMeshConcept auto&) {}
 
    void setTriangleColorsBuffer(const FaceMeshConcept auto&) {}
 
    void setVertexTextureIndicesBuffer(const FaceMeshConcept auto&) {}
 
    void setWedgeTextureIndicesBuffer(const FaceMeshConcept auto&) {}
 
    void setWireframeIndicesBuffer(const FaceMeshConcept auto&) {}
 
    void setEdgeIndicesBuffer(const EdgeMeshConcept auto&) {}
 
    void setEdgeNormalsBuffer(const EdgeMeshConcept auto&) {}
 
    void setEdgeColorsBuffer(const EdgeMeshConcept auto&) {}
 
    void setTextureUnits(const MeshConcept auto&) {}
 
    void setMeshUniforms(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()) {
                    countVerticesToDuplicateByWedgeTexCoords(
                        mesh,
                        mVertWedgeMap,
                        mVertsToDuplicate,
                        mFacesToReassign);
                }
            }
 
            mNumVerts = mesh.vertexNumber() + mVertsToDuplicate.size();
        }
 
        if constexpr (HasFaces<MeshType>) {
            if (btu[toUnderlying(TRIANGLES)])
                mNumTris = countTriangulatedTriangles(mesh);
            if (btu[toUnderlying(WIREFRAME)])
                nWireframeLines = countPerFaceVertexReferences(mesh);
        }
 
        if constexpr (HasEdges<MeshType>) {
            if (btu[toUnderlying(EDGES)])
                mNumEdges = mesh.edgeNumber();
        }
    }
 
    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 (vcl::HasPerVertexNormal<MeshType>) {
            if (vcl::isPerVertexNormalAvailable(mesh)) {
                if (btu[toUnderlying(VERT_NORMALS)]) {
                    // vertex buffer (normals)
                    derived().setVertexNormalsBuffer(mesh);
                }
            }
        }
 
        if constexpr (vcl::HasPerVertexColor<MeshType>) {
            if (vcl::isPerVertexColorAvailable(mesh)) {
                if (btu[toUnderlying(VERT_COLORS)]) {
                    // vertex buffer (colors)
                    derived().setVertexColorsBuffer(mesh);
                }
            }
        }
 
        if constexpr (vcl::HasPerVertexTexCoord<MeshType>) {
            if (vcl::isPerVertexTexCoordAvailable(mesh)) {
                if (btu[toUnderlying(VERT_TEXCOORDS)]) {
                    // vertex buffer (UVs)
                    derived().setVertexTexCoordsBuffer(mesh);
                }
            }
        }
    }
 
    void updateFacesData(
        const MeshConcept auto&       mesh,
        MeshRenderInfo::BuffersBitSet btu)
    {
        using MeshType = MeshRenderDerived::MeshType;
        using enum MRI::Buffers;
 
        if constexpr (vcl::HasFaces<MeshType>) {
            if (btu[toUnderlying(TRIANGLES)]) {
                // triangle index buffer
                derived().setTriangleIndicesBuffer(mesh);
            }
 
            if constexpr (vcl::HasPerFaceWedgeTexCoords<MeshType>) {
                if (isPerFaceWedgeTexCoordsAvailable(mesh)) {
                    if (btu[toUnderlying(WEDGE_TEXCOORDS)]) {
                        // vertex wedges buffer (duplicated vertices)
                        derived().setWedgeTexCoordsBuffer(mesh);
                    }
                }
            }
 
            if constexpr (vcl::HasPerFaceNormal<MeshType>) {
                if (vcl::isPerFaceNormalAvailable(mesh)) {
                    if (btu[toUnderlying(TRI_NORMALS)]) {
                        // triangle normal buffer
                        derived().setTriangleNormalsBuffer(mesh);
                    }
                }
            }
 
            if constexpr (vcl::HasPerFaceColor<MeshType>) {
                if (vcl::isPerFaceColorAvailable(mesh)) {
                    if (btu[toUnderlying(TRI_COLORS)]) {
                        // triangle color buffer
                        derived().setTriangleColorsBuffer(mesh);
                    }
                }
            }
 
            // texture indices are stored per face (each face has its own
            // texture index)
            if constexpr (vcl::HasPerVertexTexCoord<MeshType>) {
                if (vcl::isPerVertexTexCoordAvailable(mesh)) {
                    if (btu[toUnderlying(VERT_TEXCOORDS)]) {
                        // triangle vertex texture indices buffer
                        derived().setVertexTextureIndicesBuffer(mesh);
                    }
                }
            }
 
            if constexpr (vcl::HasPerFaceWedgeTexCoords<MeshType>) {
                if (isPerFaceWedgeTexCoordsAvailable(mesh)) {
                    if (btu[toUnderlying(WEDGE_TEXCOORDS)]) {
                        // triangle wedge texture indices buffer
                        derived().setWedgeTextureIndicesBuffer(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 (vcl::HasEdges<MeshType>) {
            if (btu[toUnderlying(EDGES)]) {
                // edge index buffer
                derived().setEdgeIndicesBuffer(mesh);
            }
 
            if constexpr (vcl::HasPerEdgeNormal<MeshType>) {
                if (vcl::isPerEdgeNormalAvailable(mesh)) {
                    if (btu[toUnderlying(EDGE_NORMALS)]) {
                        // edge normal buffer
                        derived().setEdgeNormalsBuffer(mesh);
                    }
                }
            }
 
            if constexpr (vcl::HasPerEdgeColor<MeshType>) {
                if (vcl::isPerEdgeColorAvailable(mesh)) {
                    if (btu[toUnderlying(EDGE_COLORS)]) {
                        // edge color buffer
                        derived().setEdgeColorsBuffer(mesh);
                    }
                }
            }
        }
    }
 
    void updateMeshData(
        const MeshConcept auto&       mesh,
        MeshRenderInfo::BuffersBitSet btu)
    {
        using enum MRI::Buffers;
 
        if (btu[toUnderlying(MESH_UNIFORMS)]) {
            // mesh uniforms
            derived().setMeshUniforms(mesh);
        }
    }
 
    void updateTextureData(
        const MeshConcept auto&       mesh,
        MeshRenderInfo::BuffersBitSet btu)
    {
        using MeshType = MeshRenderDerived::MeshType;
        using enum MRI::Buffers;
 
        if constexpr (vcl::HasTexturePaths<MeshType>) {
            if (btu[toUnderlying(TEXTURES)]) {
                // textures
                derived().setTextureUnits(mesh);
            }
        }
    }
};
 
} // namespace vcl
 
#endif // VCL_RENDER_DRAWABLE_MESH_MESH_RENDER_DATA_H