export_buffer.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_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_BUFFER_H
#define VCL_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_BUFFER_H
 
#include <vclib/algorithms/core.h>
#include <vclib/mesh.h>
#include <vclib/space/complex.h>
 
namespace vcl {
 
namespace detail {
 
// returns a non-empty vector if the vertex container is not compact and the
// user wants compact indices
std::vector<uint> vertCompactIndices(const auto& mesh, bool wantCompact)
{
    std::vector<uint> vertCompIndices;
 
    bool isCompact = mesh.vertexNumber() == mesh.vertexContainerSize();
 
    if (wantCompact && !isCompact)
        vertCompIndices = mesh.vertexCompactIndices();
    return vertCompIndices;
}
 
// lambda to get the vertex index of a face (considering compact vertex indices)
auto vIndexLambda(const auto& mesh, const std::vector<uint>& vertCompIndices)
{
    // lambda to get the vertex index of a face (considering compact indices)
    auto vIndex = [&vertCompIndices](const auto& f, uint i) {
        if (vertCompIndices.size() > 0)
            return vertCompIndices[f.vertexIndex(i)];
        else
            return f.vertexIndex(i);
    };
 
    return vIndex;
}
 
inline TriPolyIndexBiMap indexMap;
 
} // namespace detail
 
template<MeshConcept MeshType>
void vertexPositionsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    const uint VERT_NUM =
        rowNumber == UINT_NULL ? mesh.vertexNumber() : rowNumber;
    for (uint i = 0; const auto& c : mesh.vertices() | views::positions) {
        if (storage == MatrixStorageType::ROW_MAJOR) {
            buffer[i * 3 + 0] = c.x();
            buffer[i * 3 + 1] = c.y();
            buffer[i * 3 + 2] = c.z();
        }
        else {
            buffer[0 * VERT_NUM + i] = c.x();
            buffer[1 * VERT_NUM + i] = c.y();
            buffer[2 * VERT_NUM + i] = c.z();
        }
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexQuadIndicesToBuffer(const MeshType& mesh, auto* buffer)
{
    // creates indices for two triangles (quad) for each vertex
    //
    // 2-------3
    // | \     |
    // |  \    |
    // |   \   |
    // |    \  |
    // |     \ |
    // 0-------1
    //
    // - Triangle 1: [0, 1, 2]
    // - Triangle 2: [1, 3, 2]
    //
    for (uint i = 0; const auto& v : mesh.vertices()) {
        const uint baseIdx  = i * 6;
        const uint quadIdx  = i * 4;
        buffer[baseIdx + 0] = quadIdx + 0;
        buffer[baseIdx + 1] = quadIdx + 1;
        buffer[baseIdx + 2] = quadIdx + 2;
        buffer[baseIdx + 3] = quadIdx + 1;
        buffer[baseIdx + 4] = quadIdx + 3;
        buffer[baseIdx + 5] = quadIdx + 2;
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
uint faceSizesToBuffer(const MeshType& mesh, auto* buffer)
{
    uint sum = 0;
    for (uint i = 0; const auto& f : mesh.faces()) {
        buffer[i] = f.vertexNumber();
        sum += f.vertexNumber();
        ++i;
    }
    return sum;
}
 
template<FaceMeshConcept MeshType>
void faceIndicesToBuffer(
    const MeshType& mesh,
    auto*           buffer,
    bool            getIndicesAsIfContainerCompact = true)
{
    const std::vector<uint> vertCompIndices =
        detail::vertCompactIndices(mesh, getIndicesAsIfContainerCompact);
 
    // lambda to get the vertex index of a face (considering compact indices)
    auto vIndex = detail::vIndexLambda(mesh, vertCompIndices);
 
    for (uint i = 0; const auto& f : mesh.faces()) {
        for (uint j = 0; j < f.vertexNumber(); ++j) {
            buffer[i] = vIndex(f, j);
            ++i;
        }
    }
}
 
template<FaceMeshConcept MeshType>
void faceIndicesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestFaceSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    bool              getIndicesAsIfContainerCompact = true,
    uint              rowNumber                      = UINT_NULL)
{
    const std::vector<uint> vertCompIndices =
        detail::vertCompactIndices(mesh, getIndicesAsIfContainerCompact);
 
    // lambda to get the vertex index of a face (considering compact indices)
    auto vIndex = detail::vIndexLambda(mesh, vertCompIndices);
 
    const uint FACE_NUM =
        rowNumber == UINT_NULL ? mesh.faceNumber() : rowNumber;
 
    for (uint i = 0; const auto& f : mesh.faces()) {
        for (uint j = 0; j < largestFaceSize; ++j) {
            uint index = i * largestFaceSize + j;
            if (storage == MatrixStorageType::COLUMN_MAJOR)
                index = j * FACE_NUM + i;
            if (j < f.vertexNumber()) {
                buffer[index] = vIndex(f, j);
            }
            else {
                buffer[index] = -1;
            }
        }
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void triangulatedFaceIndicesToBuffer(
    const MeshType&    mesh,
    auto*              buffer,
    TriPolyIndexBiMap& indexMap     = detail::indexMap,
    MatrixStorageType  storage      = MatrixStorageType::ROW_MAJOR,
    uint               numTriangles = UINT_NULL,
    bool               getIndicesAsIfContainerCompact = true)
{
    const std::vector<uint> vertCompIndices =
        detail::vertCompactIndices(mesh, getIndicesAsIfContainerCompact);
 
    // lambda to get the vertex index of a face (considering compact indices)
    auto vIndex = detail::vIndexLambda(mesh, vertCompIndices);
 
    // there will be at least a triangle for each polygon
    indexMap.clear();
    indexMap.reserve(mesh.faceNumber(), mesh.faceContainerSize());
 
    if constexpr (TriangleMeshConcept<MeshType>) {
        // construct the indexMap, which maps each triangle to the face index
        for (uint t = 0; const auto& f : mesh.faces()) {
            // map the ith triangle to the f face
            indexMap.insert(t, f.index());
            ++t;
        }
 
        return faceIndicesToBuffer(
            mesh, buffer, 3, storage, getIndicesAsIfContainerCompact);
    }
    else {
        // if the user did not give the number of triangles, and the buffer
        // storage is column major, we need to compute the number of resulting
        // triangles
        if (numTriangles == UINT_NULL &&
            storage == MatrixStorageType::COLUMN_MAJOR &&
            mesh.faceNumber() > 0) {
            numTriangles = countTriangulatedTriangles(mesh);
        }
        for (uint t = 0; const auto& f : mesh.faces()) {
            std::vector<uint> vind = vcl::earCut(f);
 
            // for each triangle of the triangulation (t is the triangle index)
            for (uint vi = 0; vi < vind.size(); vi += 3) {
                // map the t-th triangle to the f polygonal face
                indexMap.insert(t, f.index());
 
                if (storage == MatrixStorageType::ROW_MAJOR) {
                    buffer[t * 3 + 0] = vIndex(f, vind[vi + 0]);
                    buffer[t * 3 + 1] = vIndex(f, vind[vi + 1]);
                    buffer[t * 3 + 2] = vIndex(f, vind[vi + 2]);
                }
                else {
                    buffer[0 * numTriangles + t] = vIndex(f, vind[vi + 0]);
                    buffer[1 * numTriangles + t] = vIndex(f, vind[vi + 1]);
                    buffer[2 * numTriangles + t] = vIndex(f, vind[vi + 2]);
                }
                ++t;
            }
        }
    }
}
 
template<EdgeMeshConcept MeshType>
void edgeIndicesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    bool              getIndicesAsIfContainerCompact = true,
    uint              rowNumber                      = UINT_NULL)
{
    const std::vector<uint> vertCompIndices =
        detail::vertCompactIndices(mesh, getIndicesAsIfContainerCompact);
 
    // lambda to get the vertex index of a edge (considering compact indices)
    auto vIndex = detail::vIndexLambda(mesh, vertCompIndices);
 
    const uint EDGE_NUM =
        rowNumber == UINT_NULL ? mesh.edgeNumber() : rowNumber;
 
    for (uint i = 0; const auto& e : mesh.edges()) {
        if (storage == MatrixStorageType::ROW_MAJOR) {
            buffer[i * 2 + 0] = vIndex(e, 0);
            buffer[i * 2 + 1] = vIndex(e, 1);
        }
        else {
            buffer[0 * EDGE_NUM + i] = vIndex(e, 0);
            buffer[1 * EDGE_NUM + i] = vIndex(e, 1);
        }
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void wireframeIndicesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    bool              getIndicesAsIfContainerCompact = true,
    uint              rowNumber                      = UINT_NULL)
{
    const std::vector<uint> vertCompIndices =
        detail::vertCompactIndices(mesh, getIndicesAsIfContainerCompact);
 
    // lambda to get the vertex index of a edge (considering compact indices)
    auto vIndex = detail::vIndexLambda(mesh, vertCompIndices);
 
    const uint EDGE_NUM =
        rowNumber == UINT_NULL ? countPerFaceVertexReferences(mesh) : rowNumber;
 
    for (uint i = 0; const auto& f : mesh.faces()) {
        for (uint j = 0; j < f.vertexNumber(); ++j) {
            uint v0 = vIndex(f, j);
            uint v1 = vIndex(f, (j + 1) % f.vertexNumber());
            if (storage == MatrixStorageType::ROW_MAJOR) {
                buffer[i * 2 + 0] = v0;
                buffer[i * 2 + 1] = v1;
            }
            else {
                buffer[0 * EDGE_NUM + i] = v0;
                buffer[1 * EDGE_NUM + i] = v1;
            }
            ++i;
        }
    }
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementSelectionToBuffer(const MeshType& mesh, auto* buffer)
{
    for (uint i = 0; const auto& e : mesh.template elements<ELEM_ID>()) {
        buffer[i] = e.selected();
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexSelectionToBuffer(const MeshType& mesh, auto* buffer)
{
    elementSelectionToBuffer<ElemId::VERTEX>(mesh, buffer);
}
 
template<FaceMeshConcept MeshType>
void faceSelectionToBuffer(const MeshType& mesh, auto* buffer)
{
    elementSelectionToBuffer<ElemId::FACE>(mesh, buffer);
}
 
template<EdgeMeshConcept MeshType>
void edgeSelectionToBuffer(const MeshType& mesh, auto* buffer)
{
    elementSelectionToBuffer<ElemId::EDGE>(mesh, buffer);
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementNormalsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    requirePerElementComponent<ELEM_ID, CompId::NORMAL>(mesh);
 
    const uint ELEM_NUM =
        rowNumber == UINT_NULL ? mesh.template number<ELEM_ID>() : rowNumber;
 
    for (uint        i = 0;
         const auto& n : mesh.template elements<ELEM_ID>() | views::normals) {
        if (storage == MatrixStorageType::ROW_MAJOR) {
            buffer[i * 3 + 0] = n.x();
            buffer[i * 3 + 1] = n.y();
            buffer[i * 3 + 2] = n.z();
        }
        else {
            buffer[0 * ELEM_NUM + i] = n.x();
            buffer[1 * ELEM_NUM + i] = n.y();
            buffer[2 * ELEM_NUM + i] = n.z();
        }
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexNormalsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    elementNormalsToBuffer<ElemId::VERTEX>(mesh, buffer, storage, rowNumber);
}
 
template<FaceMeshConcept MeshType>
void faceNormalsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    elementNormalsToBuffer<ElemId::FACE>(mesh, buffer, storage, rowNumber);
}
 
template<FaceMeshConcept MeshType>
void triangulatedFaceNormalsToBuffer(
    const MeshType&          mesh,
    auto*                    buffer,
    const TriPolyIndexBiMap& indexMap,
    MatrixStorageType        storage   = MatrixStorageType::ROW_MAJOR,
    uint                     rowNumber = UINT_NULL)
{
    requirePerFaceNormal(mesh);
 
    const uint FACE_NUM =
        rowNumber == UINT_NULL ? indexMap.triangleNumber() : rowNumber;
 
    for (const auto& f : mesh.faces()) {
        const auto& n     = f.normal();
        uint        first = indexMap.triangleBegin(f.index());
        uint        last  = first + indexMap.triangleNumber(f.index());
        for (uint t = first; t < last; ++t) {
            if (storage == MatrixStorageType::ROW_MAJOR) {
                buffer[t * 3 + 0] = n.x();
                buffer[t * 3 + 1] = n.y();
                buffer[t * 3 + 2] = n.z();
            }
            else {
                buffer[0 * FACE_NUM + t] = n.x();
                buffer[1 * FACE_NUM + t] = n.y();
                buffer[2 * FACE_NUM + t] = n.z();
            }
        }
    }
}
 
template<EdgeMeshConcept MeshType>
void edgeNormalsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    elementNormalsToBuffer<ElemId::EDGE>(mesh, buffer, storage, rowNumber);
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementColorsToBuffer(
    const MeshType&       mesh,
    auto*                 buffer,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  rowNumber      = UINT_NULL)
{
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(mesh);
 
    const bool R_INT = representation == Color::Representation::INT_0_255;
 
    const uint ELEM_NUM =
        rowNumber == UINT_NULL ? mesh.template number<ELEM_ID>() : rowNumber;
 
    for (uint        i = 0;
         const auto& c : mesh.template elements<ELEM_ID>() | views::colors) {
        if (storage == MatrixStorageType::ROW_MAJOR) {
            buffer[i * 4 + 0] = R_INT ? c.red() : c.redF();
            buffer[i * 4 + 1] = R_INT ? c.green() : c.greenF();
            buffer[i * 4 + 2] = R_INT ? c.blue() : c.blueF();
            buffer[i * 4 + 3] = R_INT ? c.alpha() : c.alphaF();
        }
        else {
            buffer[0 * ELEM_NUM + i] = R_INT ? c.red() : c.redF();
            buffer[1 * ELEM_NUM + i] = R_INT ? c.green() : c.greenF();
            buffer[2 * ELEM_NUM + i] = R_INT ? c.blue() : c.blueF();
            buffer[3 * ELEM_NUM + i] = R_INT ? c.alpha() : c.alphaF();
        }
        ++i;
    }
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementColorsToBuffer(
    const MeshType& mesh,
    auto*           buffer,
    Color::Format   colorFormat)
{
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(mesh);
 
    for (uint        i = 0;
         const auto& c : mesh.template elements<ELEM_ID>() | views::colors) {
        switch (colorFormat) {
            using enum Color::Format;
        case ABGR: buffer[i] = c.abgr(); break;
        case ARGB: buffer[i] = c.argb(); break;
        case RGBA: buffer[i] = c.rgba(); break;
        case BGRA: buffer[i] = c.bgra(); break;
        }
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexColorsToBuffer(
    const MeshType&       mesh,
    auto*                 buffer,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  rowNumber      = UINT_NULL)
{
    elementColorsToBuffer<ElemId::VERTEX>(
        mesh, buffer, storage, representation, rowNumber);
}
 
template<MeshConcept MeshType>
void vertexColorsToBuffer(
    const MeshType& mesh,
    auto*           buffer,
    Color::Format   colorFormat)
{
    elementColorsToBuffer<ElemId::VERTEX>(mesh, buffer, colorFormat);
}
 
template<FaceMeshConcept MeshType>
void faceColorsToBuffer(
    const MeshType&       mesh,
    auto*                 buffer,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  rowNumber      = UINT_NULL)
{
    elementColorsToBuffer<ElemId::FACE>(
        mesh, buffer, storage, representation, rowNumber);
}
 
template<FaceMeshConcept MeshType>
void triangulatedFaceColorsToBuffer(
    const MeshType&          mesh,
    auto*                    buffer,
    const TriPolyIndexBiMap& indexMap,
    MatrixStorageType        storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation    representation = Color::Representation::INT_0_255,
    uint                     rowNumber      = UINT_NULL)
{
    requirePerFaceColor(mesh);
 
    const bool R_INT = representation == Color::Representation::INT_0_255;
 
    const uint FACE_NUM =
        rowNumber == UINT_NULL ? indexMap.triangleNumber() : rowNumber;
 
    for (const auto& f : mesh.faces()) {
        const auto& c     = f.color();
        uint        first = indexMap.triangleBegin(f.index());
        uint        last  = first + indexMap.triangleNumber(f.index());
        for (uint t = first; t < last; ++t) {
            if (storage == MatrixStorageType::ROW_MAJOR) {
                buffer[t * 4 + 0] = R_INT ? c.red() : c.redF();
                buffer[t * 4 + 1] = R_INT ? c.green() : c.greenF();
                buffer[t * 4 + 2] = R_INT ? c.blue() : c.blueF();
                buffer[t * 4 + 3] = R_INT ? c.alpha() : c.alphaF();
            }
            else {
                buffer[0 * FACE_NUM + t] = R_INT ? c.red() : c.redF();
                buffer[1 * FACE_NUM + t] = R_INT ? c.green() : c.greenF();
                buffer[2 * FACE_NUM + t] = R_INT ? c.blue() : c.blueF();
                buffer[3 * FACE_NUM + t] = R_INT ? c.alpha() : c.alphaF();
            }
        }
    }
}
 
template<FaceMeshConcept MeshType>
void faceColorsToBuffer(
    const MeshType& mesh,
    auto*           buffer,
    Color::Format   colorFormat)
{
    elementColorsToBuffer<ElemId::FACE>(mesh, buffer, colorFormat);
}
 
template<FaceMeshConcept MeshType>
void triangulatedFaceColorsToBuffer(
    const MeshType&          mesh,
    auto*                    buffer,
    const TriPolyIndexBiMap& indexMap,
    Color::Format            colorFormat)
{
    requirePerElementComponent<ElemId::FACE, CompId::COLOR>(mesh);
 
    for (const auto& f : mesh.faces()) {
        const auto& c     = f.color();
        uint        first = indexMap.triangleBegin(f.index());
        uint        last  = first + indexMap.triangleNumber(f.index());
        for (uint t = first; t < last; ++t) {
            switch (colorFormat) {
                using enum Color::Format;
            case ABGR: buffer[t] = c.abgr(); break;
            case ARGB: buffer[t] = c.argb(); break;
            case RGBA: buffer[t] = c.rgba(); break;
            case BGRA: buffer[t] = c.bgra(); break;
            }
        }
    }
}
 
template<EdgeMeshConcept MeshType>
void edgeColorsToBuffer(
    const MeshType&       mesh,
    auto*                 buffer,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  rowNumber      = UINT_NULL)
{
    elementColorsToBuffer<ElemId::EDGE>(
        mesh, buffer, storage, representation, rowNumber);
}
 
template<EdgeMeshConcept MeshType>
void edgeColorsToBuffer(
    const MeshType& mesh,
    auto*           buffer,
    Color::Format   colorFormat)
{
    elementColorsToBuffer<ElemId::EDGE>(mesh, buffer, colorFormat);
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementQualityToBuffer(const MeshType& mesh, auto* buffer)
{
    requirePerElementComponent<ELEM_ID, CompId::QUALITY>(mesh);
 
    for (uint        i = 0;
         const auto& q : mesh.template elements<ELEM_ID>() | views::quality) {
        buffer[i] = q;
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexQualityToBuffer(const MeshType& mesh, auto* buffer)
{
    elementQualityToBuffer<ElemId::VERTEX>(mesh, buffer);
}
 
template<MeshConcept MeshType>
void faceQualityToBuffer(const MeshType& mesh, auto* buffer)
{
    elementQualityToBuffer<ElemId::FACE>(mesh, buffer);
}
 
template<MeshConcept MeshType>
void edgeQualityToBuffer(const MeshType& mesh, auto* buffer)
{
    elementQualityToBuffer<ElemId::FACE>(mesh, buffer);
}
 
template<MeshConcept MeshType>
void vertexTexCoordsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    requirePerVertexTexCoord(mesh);
 
    const uint VERT_NUM =
        rowNumber == UINT_NULL ? mesh.vertexNumber() : rowNumber;
 
    for (uint i = 0; const auto& t : mesh.vertices() | views::texCoords) {
        if (storage == MatrixStorageType::ROW_MAJOR) {
            buffer[i * 2 + 0] = t.u();
            buffer[i * 2 + 1] = t.v();
        }
        else {
            buffer[0 * VERT_NUM + i] = t.u();
            buffer[1 * VERT_NUM + i] = t.v();
        }
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexTexCoordIndicesToBuffer(const MeshType& mesh, auto* buffer)
{
    requirePerVertexTexCoord(mesh);
 
    for (uint i = 0; const auto& t : mesh.vertices() | views::texCoords) {
        buffer[i] = t.index();
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void vertexTexCoordIndicesAsFaceTexCoordIndicesToBuffer(
    const MeshType& mesh,
    auto*           buffer)
{
    requirePerVertexTexCoord(mesh);
 
    for (uint i = 0; const auto& f : mesh.faces()) {
        ushort ti = f.vertex(0)->texCoord()->index();
        buffer[i] = ti;
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void vertexTexCoordIndicesAsTriangulatedFaceTexCoordIndicesToBuffer(
    const MeshType&          mesh,
    auto*                    buffer,
    const TriPolyIndexBiMap& indexMap)
{
    requirePerVertexTexCoord(mesh);
 
    for (const auto& f : mesh.faces()) {
        ushort ti    = f.vertex(0)->texCoord().index();
        uint   first = indexMap.triangleBegin(f.index());
        uint   last  = first + indexMap.triangleNumber(f.index());
        for (uint t = first; t < last; ++t) {
            buffer[t] = ti;
        }
    }
}
 
template<FaceMeshConcept MeshType>
void faceWedgeTexCoordsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestFaceSize = 3,
    MatrixStorageType storage         = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber       = UINT_NULL)
{
    requirePerFaceWedgeTexCoords(mesh);
 
    const uint FACE_NUM =
        rowNumber == UINT_NULL ? mesh.faceNumber() : rowNumber;
 
    for (uint i = 0; const auto& f : mesh.faces()) {
        for (uint j = 0; j < largestFaceSize * 2; ++j) {
            uint fi    = j / 2;
            uint index = i * largestFaceSize * 2 + j;
            if (storage == MatrixStorageType::COLUMN_MAJOR)
                index = j * FACE_NUM + i;
            if (fi < f.wedgeTexCoordsNumber()) {
                const auto& w = f.wedgeTexCoord(fi);
                if (j % 2 == 0)
                    buffer[index] = w.u();
                else
                    buffer[index] = w.v();
            }
            else {
                buffer[index] = 0;
            }
        }
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void faceWedgeTexCoordIndicesToBuffer(const MeshType& mesh, auto* buffer)
{
    requirePerFaceWedgeTexCoords(mesh);
 
    for (uint i = 0; const auto& f : mesh.faces()) {
        buffer[i] = f.textureIndex();
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void triangulatedFaceWedgeTexCoordIndicesToBuffer(
    const MeshType&          mesh,
    auto*                    buffer,
    const TriPolyIndexBiMap& indexMap)
{
    requirePerFaceWedgeTexCoords(mesh);
 
    for (const auto& f : mesh.faces()) {
        uint first = indexMap.triangleBegin(f.index());
        uint last  = first + indexMap.triangleNumber(f.index());
        for (uint t = first; t < last; ++t) {
            buffer[t] = f.textureIndex();
        }
    }
}
 
template<FaceMeshConcept MeshType>
void wedgeTexCoordsAsDuplicatedVertexTexCoordsToBuffer(
    const MeshType&                                     mesh,
    const std::vector<std::pair<vcl::uint, vcl::uint>>& vertWedgeMap,
    const std::list<std::list<std::pair<vcl::uint, vcl::uint>>>&
                      facesToReassign,
    auto*             buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR)
{
    using TexCoordType = typename MeshType::FaceType::WedgeTexCoordType;
 
    requirePerFaceWedgeTexCoords(mesh);
 
    const uint VERT_NUM = mesh.vertexNumber() + facesToReassign.size();
 
    // first export the texcoords of the non-duplicated vertices, using the
    // vertWedgeMap to get the texcoord index in the face
    uint vi = 0; // current vertex (or current row in the matrix)
    for (const auto& v : mesh.vertices()) {
        TexCoordType w;
        uint         fInd = vertWedgeMap[vi].first;
        uint         wInd = vertWedgeMap[vi].second;
 
        // check if the vi is referenced
        if (fInd != UINT_NULL && wInd != UINT_NULL) {
            w = mesh.face(fInd).wedgeTexCoord(wInd);
        }
        if (storage == MatrixStorageType::ROW_MAJOR) {
            buffer[vi * 2 + 0] = w.u();
            buffer[vi * 2 + 1] = w.v();
        }
        else {
            buffer[0 * VERT_NUM + vi] = w.u();
            buffer[1 * VERT_NUM + vi] = w.v();
        }
        ++vi;
    }
 
    // then append the texcoords of the duplicated vertices, that can be found
    // by looking into the any of the facesToReassign element lists
    for (const auto& list : facesToReassign) {
        assert(list.begin() != list.end());
        const auto& p    = list.front();
        uint        fInd = p.first;
        uint        wInd = p.second;
 
        const auto& w = mesh.face(fInd).wedgeTexCoord(wInd);
        if (storage == MatrixStorageType::ROW_MAJOR) {
            buffer[vi * 2 + 0] = w.u();
            buffer[vi * 2 + 1] = w.v();
        }
        else {
            buffer[0 * VERT_NUM + vi] = w.u();
            buffer[1 * VERT_NUM + vi] = w.v();
        }
        ++vi;
    }
}
 
template<FaceMeshConcept MeshType>
void wedgeTexCoordIndicesAsDuplicatedVertexTexCoordIndicesToBuffer(
    const MeshType&                                     mesh,
    const std::vector<std::pair<vcl::uint, vcl::uint>>& vertWedgeMap,
    const std::list<std::list<std::pair<vcl::uint, vcl::uint>>>&
          facesToReassign,
    auto* buffer)
{
    requirePerFaceWedgeTexCoords(mesh);
 
    const uint VERT_NUM = mesh.vertexNumber() + facesToReassign.size();
 
    // first export the tex indices of the non-duplicated vertices, using the
    // vertWedgeMap to get the texcoord index in the face
    uint vi = 0; // current vertex (or current row in the matrix)
    for (const auto& v : mesh.vertices()) {
        uint   fInd = vertWedgeMap[vi].first;
        ushort ti   = mesh.face(fInd).textureIndex();
        buffer[vi]  = ti;
        ++vi;
    }
 
    // then append the tex indices of the duplicated vertices, that can be found
    // by looking into the any of the facesToReassign element lists
    for (const auto& list : facesToReassign) {
        assert(list.begin() != list.end());
        const auto& p    = list.front();
        uint        fInd = p.first;
 
        ushort ti  = mesh.face(fInd).textureIndex();
        buffer[vi] = ti;
        ++vi;
    }
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_BUFFER_H