export_buffer.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_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_BUFFER_H
#define VCL_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_BUFFER_H
 
#include "detail.h"
 
#include <vclib/algorithms/mesh/utility.h>
 
#include <vclib/algorithms/core.h>
#include <vclib/mesh.h>
#include <vclib/space/complex.h>
 
namespace vcl {
 
namespace detail {
 
inline TriPolyIndexBiMap indexMap;
 
} // namespace detail
 
template<MeshConcept MeshType>
void vertexPositionsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    using namespace detail;
 
    const uint NUM_ROWS = numRows == UINT_NULL ? mesh.vertexCount() : numRows;
    for (uint i = 0; const auto& p : mesh.vertices() | views::positions) {
        at(buffer, i, 0, NUM_ROWS, 3, storage) = p.x();
        at(buffer, i, 1, NUM_ROWS, 3, storage) = p.y();
        at(buffer, i, 2, NUM_ROWS, 3, storage) = p.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.vertexCount();
        sum += f.vertexCount();
        ++i;
    }
    return sum;
}
 
template<FaceMeshConcept MeshType>
void faceVertexIndicesToBuffer(
    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.vertexCount(); ++j) {
            buffer[i] = vIndex(f, j);
            ++i;
        }
    }
}
 
template<FaceMeshConcept MeshType>
void faceVertexIndicesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestFaceSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    bool              getIndicesAsIfContainerCompact = true,
    uint              numRows                        = UINT_NULL)
{
    using namespace detail;
 
    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 NUM_ROWS = numRows == UINT_NULL ? mesh.faceCount() : numRows;
 
    for (uint i = 0; const auto& f : mesh.faces()) {
        for (uint j = 0; j < largestFaceSize; ++j) {
            at(buffer, i, j, NUM_ROWS, largestFaceSize, storage) =
                j < f.vertexCount() ? vIndex(f, j) : -1;
        }
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void triangulatedFaceVertexIndicesToBuffer(
    const MeshType&    mesh,
    auto*              buffer,
    TriPolyIndexBiMap& indexMap     = detail::indexMap,
    MatrixStorageType  storage      = MatrixStorageType::ROW_MAJOR,
    uint               numTriangles = UINT_NULL,
    bool               getIndicesAsIfContainerCompact = true)
{
    using namespace detail;
 
    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.faceCount(), 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 faceVertexIndicesToBuffer(
            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.faceCount() > 0) {
            numTriangles = triangulatedFaceCount(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());
 
                for (uint k = 0; k < 3; ++k)
                    at(buffer, t, k, numTriangles, 3, storage) =
                        vIndex(f, vind[vi + k]);
 
                ++t;
            }
        }
    }
}
 
template<EdgeMeshConcept MeshType>
void edgeVertexIndicesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    bool              getIndicesAsIfContainerCompact = true,
    uint              numRows                        = UINT_NULL)
{
    using namespace detail;
 
    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 NUM_ROWS = numRows == UINT_NULL ? mesh.edgeCount() : numRows;
 
    for (uint i = 0; const auto& e : mesh.edges()) {
        at(buffer, i, 0, NUM_ROWS, 2, storage) = vIndex(e, 0);
        at(buffer, i, 1, NUM_ROWS, 2, storage) = vIndex(e, 1);
 
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void wireframeVertexIndicesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    bool              getIndicesAsIfContainerCompact = true,
    uint              numRows                        = UINT_NULL)
{
    using namespace detail;
 
    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 NUM_ROWS =
        numRows == UINT_NULL ? faceVertexReferencesCount(mesh) : numRows;
 
    for (uint i = 0; const auto& f : mesh.faces()) {
        for (uint j = 0; j < f.vertexCount(); ++j) {
            uint v0 = vIndex(f, j);
            uint v1 = vIndex(f, (j + 1) % f.vertexCount());
 
            at(buffer, i, 0, NUM_ROWS, 2, storage) = v0;
            at(buffer, i, 1, NUM_ROWS, 2, storage) = 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              numRows = UINT_NULL)
{
    using namespace detail;
 
    requirePerElementComponent<ELEM_ID, CompId::NORMAL>(mesh);
 
    const uint NUM_ROWS =
        numRows == UINT_NULL ? mesh.template count<ELEM_ID>() : numRows;
 
    for (uint        i = 0;
         const auto& n : mesh.template elements<ELEM_ID>() | views::normals) {
        at(buffer, i, 0, NUM_ROWS, 3, storage) = n.x();
        at(buffer, i, 1, NUM_ROWS, 3, storage) = n.y();
        at(buffer, i, 2, NUM_ROWS, 3, storage) = n.z();
 
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexNormalsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    elementNormalsToBuffer<ElemId::VERTEX>(mesh, buffer, storage, numRows);
}
 
template<FaceMeshConcept MeshType>
void faceNormalsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    elementNormalsToBuffer<ElemId::FACE>(mesh, buffer, storage, numRows);
}
 
template<FaceMeshConcept MeshType>
void triangulatedFaceNormalsToBuffer(
    const MeshType&          mesh,
    auto*                    buffer,
    const TriPolyIndexBiMap& indexMap,
    MatrixStorageType        storage = MatrixStorageType::ROW_MAJOR,
    uint                     numRows = UINT_NULL)
{
    using namespace detail;
 
    requirePerFaceNormal(mesh);
 
    const uint NUM_ROWS =
        numRows == UINT_NULL ? indexMap.triangleCount() : numRows;
 
    for (const auto& f : mesh.faces()) {
        const auto& n     = f.normal();
        uint        first = indexMap.triangleBegin(f.index());
        uint        last  = first + indexMap.triangleCount(f.index());
        for (uint t = first; t < last; ++t) {
            at(buffer, t, 0, NUM_ROWS, 3, storage) = n.x();
            at(buffer, t, 1, NUM_ROWS, 3, storage) = n.y();
            at(buffer, t, 2, NUM_ROWS, 3, storage) = n.z();
        }
    }
}
 
template<EdgeMeshConcept MeshType>
void edgeNormalsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    elementNormalsToBuffer<ElemId::EDGE>(mesh, buffer, storage, numRows);
}
 
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                  numRows        = UINT_NULL)
{
    using namespace detail;
 
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(mesh);
 
    const bool R_INT = representation == Color::Representation::INT_0_255;
 
    const uint NUM_ROWS =
        numRows == UINT_NULL ? mesh.template count<ELEM_ID>() : numRows;
 
    for (uint        i = 0;
         const auto& c : mesh.template elements<ELEM_ID>() | views::colors) {
        at(buffer, i, 0, NUM_ROWS, 4, storage) = R_INT ? c.red() : c.redF();
        at(buffer, i, 1, NUM_ROWS, 4, storage) = R_INT ? c.green() : c.greenF();
        at(buffer, i, 2, NUM_ROWS, 4, storage) = R_INT ? c.blue() : c.blueF();
        at(buffer, i, 3, NUM_ROWS, 4, storage) = 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                  numRows        = UINT_NULL)
{
    elementColorsToBuffer<ElemId::VERTEX>(
        mesh, buffer, storage, representation, numRows);
}
 
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                  numRows        = UINT_NULL)
{
    elementColorsToBuffer<ElemId::FACE>(
        mesh, buffer, storage, representation, numRows);
}
 
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                     numRows        = UINT_NULL)
{
    using namespace detail;
 
    requirePerFaceColor(mesh);
 
    const bool R_INT = representation == Color::Representation::INT_0_255;
 
    const uint NUM_ROWS =
        numRows == UINT_NULL ? indexMap.triangleCount() : numRows;
 
    for (const auto& f : mesh.faces()) {
        const auto& c     = f.color();
        uint        first = indexMap.triangleBegin(f.index());
        uint        last  = first + indexMap.triangleCount(f.index());
        for (uint t = first; t < last; ++t) {
            at(buffer, t, 0, NUM_ROWS, 4, storage) = R_INT ? c.red() : c.redF();
            at(buffer, t, 1, NUM_ROWS, 4, storage) =
                R_INT ? c.green() : c.greenF();
            at(buffer, t, 2, NUM_ROWS, 4, storage) =
                R_INT ? c.blue() : c.blueF();
            at(buffer, t, 3, NUM_ROWS, 4, storage) =
                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.triangleCount(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                  numRows        = UINT_NULL)
{
    elementColorsToBuffer<ElemId::EDGE>(
        mesh, buffer, storage, representation, numRows);
}
 
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 vertexTangentsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    bool              storeHandednessAsW = true,
    MatrixStorageType storage            = MatrixStorageType::ROW_MAJOR,
    uint              numRows            = UINT_NULL)
{
    using namespace detail;
 
    requirePerVertexTangent(mesh);
 
    const uint NUM_ROWS = numRows == UINT_NULL ? mesh.vertexCount() : numRows;
    const uint NUM_COLS = storeHandednessAsW ? 4 : 3;
 
    for (uint i = 0; const auto& v : mesh.vertices()) {
        at(buffer, i, 0, NUM_ROWS, NUM_COLS, storage) = v.tangent().x();
        at(buffer, i, 1, NUM_ROWS, NUM_COLS, storage) = v.tangent().y();
        at(buffer, i, 2, NUM_ROWS, NUM_COLS, storage) = v.tangent().z();
        if (storeHandednessAsW) {
            at(buffer, i, 3, NUM_ROWS, NUM_COLS, storage) =
                v.tangentRightHanded() ? 1.0 : -1.0;
        }
 
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexTexCoordsToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    using namespace detail;
 
    requirePerVertexTexCoord(mesh);
 
    const uint NUM_ROWS = numRows == UINT_NULL ? mesh.vertexCount() : numRows;
 
    for (uint i = 0; const auto& t : mesh.vertices() | views::texCoords) {
        at(buffer, i, 0, NUM_ROWS, 2, storage) = t.u();
        at(buffer, i, 1, NUM_ROWS, 2, storage) = t.v();
 
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexMaterialIndicesToBuffer(const MeshType& mesh, auto* buffer)
{
    requirePerVertexMaterialIndex(mesh);
 
    for (uint i = 0; const auto& v : mesh.vertices()) {
        buffer[i] = v.materialIndex();
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void vertexMaterialIndicesAsFaceMaterialIndicesToBuffer(
    const MeshType& mesh,
    auto*           buffer)
{
    requirePerVertexMaterialIndex(mesh);
 
    for (uint i = 0; const auto& f : mesh.faces()) {
        ushort ti = f.vertex(0)->materialIndex();
        buffer[i] = ti;
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void vertexMaterialIndicesAsTriangulatedFaceMaterialIndicesToBuffer(
    const MeshType&          mesh,
    auto*                    buffer,
    const TriPolyIndexBiMap& indexMap)
{
    requirePerVertexMaterialIndex(mesh);
 
    for (const auto& f : mesh.faces()) {
        ushort ti    = f.vertex(0)->materialIndex();
        uint   first = indexMap.triangleBegin(f.index());
        uint   last  = first + indexMap.triangleCount(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              numRows         = UINT_NULL)
{
    requirePerFaceWedgeTexCoords(mesh);
 
    const uint NUM_ROWS = numRows == UINT_NULL ? mesh.faceCount() : numRows;
 
    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 * NUM_ROWS + i;
            if (fi < f.vertexCount()) {
                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 faceMaterialIndicesToBuffer(const MeshType& mesh, auto* buffer)
{
    requirePerFaceMaterialIndex(mesh);
 
    for (uint i = 0; const auto& f : mesh.faces()) {
        buffer[i] = f.materialIndex();
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void triangulatedFaceMaterialIndicesToBuffer(
    const MeshType&          mesh,
    auto*                    buffer,
    const TriPolyIndexBiMap& indexMap)
{
    requirePerFaceMaterialIndex(mesh);
 
    for (const auto& f : mesh.faces()) {
        uint first = indexMap.triangleBegin(f.index());
        uint last  = first + indexMap.triangleCount(f.index());
        for (uint t = first; t < last; ++t) {
            buffer[t] = f.materialIndex();
        }
    }
}
 
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 namespace detail;
    using TexCoordType = typename MeshType::FaceType::WedgeTexCoordType;
 
    requirePerFaceWedgeTexCoords(mesh);
 
    const uint NUM_ROWS = mesh.vertexCount() + 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);
        }
        at(buffer, vi, 0, NUM_ROWS, 2, storage) = w.u();
        at(buffer, vi, 1, NUM_ROWS, 2, storage) = 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);
        at(buffer, vi, 0, NUM_ROWS, 2, storage) = w.u();
        at(buffer, vi, 1, NUM_ROWS, 2, storage) = w.v();
 
        ++vi;
    }
}
 
template<FaceMeshConcept MeshType>
void faceMaterialIndicesAsDuplicatedVertexMaterialIndicesToBuffer(
    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)
{
    requirePerFaceMaterialIndex(mesh);
 
    const uint VERT_NUM = mesh.vertexCount() + facesToReassign.size();
 
    // first export the material indices of the non-duplicated vertices, using
    // the vertWedgeMap to get the material 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).materialIndex();
        buffer[vi]  = ti;
        ++vi;
    }
 
    // then append the material 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).materialIndex();
        buffer[vi] = ti;
        ++vi;
    }
}
 
template<MeshConcept MeshType>
void vertexAdjacentVerticesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestAdjacentVerticesSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    using namespace detail;
 
    requireVertexContainerCompactness(mesh);
    requirePerVertexAdjacentVertices(mesh);
 
    const uint NUM_ROWS = numRows == UINT_NULL ? mesh.vertexCount() : numRows;
 
    const uint NUM_COLS = largestAdjacentVerticesSize;
 
    for (uint i = 0; const auto& v : mesh.vertices()) {
        uint adjIndex = 0;
        for (const auto* a : v.adjVertices()) {
            uint idx = a ? a->index() : UINT_NULL;
            at(buffer, i, adjIndex, NUM_ROWS, NUM_COLS, storage) = idx;
            ++adjIndex;
        }
        // fill the remaining entries with UINT_NULL
        for (; adjIndex < NUM_COLS; ++adjIndex) {
            at(buffer, i, adjIndex, NUM_ROWS, NUM_COLS, storage) = UINT_NULL;
        }
        ++i;
    }
}
 
template<uint ELEM_ID, FaceMeshConcept MeshType>
void elementAdjacentFacesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestAdjacentFacesSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    using namespace detail;
 
    requireFaceContainerCompactness(mesh);
    requirePerElementComponent<ELEM_ID, CompId::ADJACENT_FACES>(mesh);
 
    const uint NUM_ROWS =
        numRows == UINT_NULL ? mesh.template count<ELEM_ID>() : numRows;
 
    const uint NUM_COLS = largestAdjacentFacesSize;
 
    for (uint i = 0; const auto& v : mesh.template elements<ELEM_ID>()) {
        uint adjIndex = 0;
        for (const auto* a : v.adjFaces()) {
            uint idx = a ? a->index() : UINT_NULL;
            at(buffer, i, adjIndex, NUM_ROWS, NUM_COLS, storage) = idx;
            ++adjIndex;
        }
        // fill the remaining entries with UINT_NULL
        for (; adjIndex < NUM_COLS; ++adjIndex) {
            at(buffer, i, adjIndex, NUM_ROWS, NUM_COLS, storage) = UINT_NULL;
        }
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void vertexAdjacentFacesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestAdjacentFacesSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    elementAdjacentFacesToBuffer<ElemId::VERTEX>(
        mesh, buffer, largestAdjacentFacesSize, storage, numRows);
}
 
template<FaceMeshConcept MeshType>
void faceAdjacentFacesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestFacesSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    elementAdjacentFacesToBuffer<ElemId::FACE>(
        mesh, buffer, largestFacesSize, storage, numRows);
}
 
template<FaceMeshConcept MeshType>
void edgeAdjacentFacesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestAdjacentFacesSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL) requires (EdgeMeshConcept<MeshType>)
{
    elementAdjacentFacesToBuffer<ElemId::EDGE>(
        mesh, buffer, largestAdjacentFacesSize, storage, numRows);
}
 
template<uint ELEM_ID, EdgeMeshConcept MeshType>
void elementAdjacentEdgesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestAdjacentEdgesSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    using namespace detail;
 
    requireEdgeContainerCompactness(mesh);
    requirePerElementComponent<ELEM_ID, CompId::ADJACENT_EDGES>(mesh);
 
    const uint NUM_ROWS =
        numRows == UINT_NULL ? mesh.template count<ELEM_ID>() : numRows;
 
    const uint NUM_COLS = largestAdjacentEdgesSize;
 
    for (uint i = 0; const auto& v : mesh.template elements<ELEM_ID>()) {
        uint adjIndex = 0;
        for (const auto* a : v.adjEdges()) {
            uint idx = a ? a->index() : UINT_NULL;
            at(buffer, i, adjIndex, NUM_ROWS, NUM_COLS, storage) = idx;
            ++adjIndex;
        }
        // fill the remaining entries with UINT_NULL
        for (; adjIndex < NUM_COLS; ++adjIndex) {
            at(buffer, i, adjIndex, NUM_ROWS, NUM_COLS, storage) = UINT_NULL;
        }
        ++i;
    }
}
 
template<EdgeMeshConcept MeshType>
void vertexAdjacentEdgesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestAdjacentEdgesSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    elementAdjacentEdgesToBuffer<ElemId::VERTEX>(
        mesh, buffer, largestAdjacentEdgesSize, storage, numRows);
}
 
template<EdgeMeshConcept MeshType>
void faceAdjacentEdgesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestAdjacentEdgesSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL) requires (FaceMeshConcept<MeshType>)
{
    elementAdjacentEdgesToBuffer<ElemId::FACE>(
        mesh, buffer, largestAdjacentEdgesSize, storage, numRows);
}
 
template<EdgeMeshConcept MeshType>
void edgeAdjacentEdgesToBuffer(
    const MeshType&   mesh,
    auto*             buffer,
    uint              largestAdjacentEdgesSize,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    elementAdjacentEdgesToBuffer<ElemId::EDGE>(
        mesh, buffer, largestAdjacentEdgesSize, storage, numRows);
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_BUFFER_H