append_replace_to_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_APPEND_REPLACE_TO_BUFFER_H
#define VCL_ALGORITHMS_MESH_IMPORT_EXPORT_APPEND_REPLACE_TO_BUFFER_H
 
#include <vclib/mesh.h>
#include <vclib/space/complex.h>
 
namespace vcl {
 
template<MeshConcept MeshType>
void appendDuplicateVertexPositionsToBuffer(
    const MeshType&        mesh,
    const std::list<uint>& vertsToDuplicate,
    auto*                  buffer,
    MatrixStorageType      storage = MatrixStorageType::ROW_MAJOR)
{
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    const uint VERT_NUM = mesh.vertexNumber() + vertsToDuplicate.size();
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        const auto& pos = mesh.vertex(v).position();
        if (storage == MatrixStorageType::ROW_MAJOR) {
            buffer[i * 3 + 0] = pos.x();
            buffer[i * 3 + 1] = pos.y();
            buffer[i * 3 + 2] = pos.z();
        }
        else {
            buffer[0 * VERT_NUM + i] = pos.x();
            buffer[1 * VERT_NUM + i] = pos.y();
            buffer[2 * VERT_NUM + i] = pos.z();
        }
 
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void replaceFaceIndicesByVertexDuplicationToBuffer(
    const MeshType&                                    mesh,
    const std::list<uint>&                             vertsToDuplicate,
    const std::list<std::list<std::pair<uint, uint>>>& facesToReassign,
    auto*                                              buffer,
    uint                                               largestFaceSize = 3,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR)
{
    // no vertices have been duplicated, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    assert(vertsToDuplicate.size() == facesToReassign.size());
 
    const uint FACE_NUM = mesh.faceNumber();
 
    uint vFirst = mesh.vertexNumber();
    uint vLast  = mesh.vertexNumber() + vertsToDuplicate.size();
    for (uint vi = vFirst; const auto& faces : facesToReassign) {
        for (const auto& f : faces) {
            if (storage == MatrixStorageType::ROW_MAJOR)
                buffer[f.first * largestFaceSize + f.second] = vi;
            else
                buffer[f.second * FACE_NUM + f.first] = vi;
        }
        ++vi;
    }
}
 
template<FaceMeshConcept MeshType>
void replaceTriangulatedFaceIndicesByVertexDuplicationToBuffer(
    const MeshType&                                    mesh,
    const std::list<uint>&                             vertsToDuplicate,
    const std::list<std::list<std::pair<uint, uint>>>& facesToReassign,
    const TriPolyIndexBiMap&                           indexMap,
    auto*                                              buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR)
{
    // no vertices have been duplicated, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    assert(vertsToDuplicate.size() == facesToReassign.size());
 
    uint vFirst = mesh.vertexNumber();
    uint vLast  = mesh.vertexNumber() + vertsToDuplicate.size();
 
    const uint FACE_NUM = indexMap.triangleNumber();
 
    // the facesToReassign lists for each vertex contain pairs that in the
    // second element store the index of the vertex in the face. However, the
    // face has been triangulated, and this info is not useful anymore. We need
    // to look into the triangles generated for the face (first elem of the
    // pair) and look for the vertex index to set (that is the vertex index
    // stored in the vertsToDuplicate list).
    for (uint vi = vFirst; const auto& [vert, faces] :
                           std::views::zip(vertsToDuplicate, facesToReassign)) {
        // vert is the vertex index in the mesh that we need to reassign with
        // the index vi in the buffer
 
        // for each face f that has at least a vertex to reassign
        for (const auto& f : faces) {
            // get the triangle indices of the face using the index map
            uint tBegin = indexMap.triangleBegin(f.first);
            uint tEnd   = tBegin + indexMap.triangleNumber(f.first);
            for (uint t = tBegin; t < tEnd; ++t) { // look into the triangles
                for (uint j = 0; j < 3; ++j) { // for each vertex of triangle
                    if (storage == MatrixStorageType::ROW_MAJOR) {
                        if (buffer[t * 3 + j] == vert) {
                            buffer[t * 3 + j] = vi;
                        }
                    }
                    else {
                        if (buffer[j * FACE_NUM + t] == vert) {
                            buffer[j * FACE_NUM + t] = vi;
                        }
                    }
                }
            }
        }
        ++vi;
    }
}
 
template<MeshConcept MeshType>
void appendDuplicateVertexSelectionToBuffer(
    const MeshType&        mesh,
    const std::list<uint>& vertsToDuplicate,
    auto*                  buffer)
{
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        buffer[i] = mesh.vertex(v).selected();
        ++i;
    }
}
 
template<MeshConcept MeshType>
void appendDuplicateVertexNormalsToBuffer(
    const MeshType&        mesh,
    const std::list<uint>& vertsToDuplicate,
    auto*                  buffer,
    MatrixStorageType      storage = MatrixStorageType::ROW_MAJOR)
{
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexNormal(mesh);
 
    const uint VERT_NUM = mesh.vertexNumber() + vertsToDuplicate.size();
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        const auto& normal = mesh.vertex(v).normal();
        if (storage == MatrixStorageType::ROW_MAJOR) {
            buffer[i * 3 + 0] = normal.x();
            buffer[i * 3 + 1] = normal.y();
            buffer[i * 3 + 2] = normal.z();
        }
        else {
            buffer[0 * VERT_NUM + i] = normal.x();
            buffer[1 * VERT_NUM + i] = normal.y();
            buffer[2 * VERT_NUM + i] = normal.z();
        }
        ++i;
    }
}
 
template<MeshConcept MeshType>
void appendDuplicateVertexColorsToBuffer(
    const MeshType&        mesh,
    const std::list<uint>& vertsToDuplicate,
    auto*                  buffer,
    Color::Representation  representation = Color::Representation::INT_0_255,
    MatrixStorageType      storage        = MatrixStorageType::ROW_MAJOR)
{
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexColor(mesh);
 
    const bool R_INT    = representation == Color::Representation::INT_0_255;
    const uint VERT_NUM = mesh.vertexNumber() + vertsToDuplicate.size();
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        const auto& c = mesh.vertex(v).color();
        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 * VERT_NUM + i] = R_INT ? c.red() : c.redF();
            buffer[1 * VERT_NUM + i] = R_INT ? c.green() : c.greenF();
            buffer[2 * VERT_NUM + i] = R_INT ? c.blue() : c.blueF();
            buffer[3 * VERT_NUM + i] = R_INT ? c.alpha() : c.alphaF();
        }
        ++i;
    }
}
 
template<MeshConcept MeshType>
void appendDuplicateVertexColorsToBuffer(
    const MeshType&        mesh,
    const std::list<uint>& vertsToDuplicate,
    auto*                  buffer,
    Color::Format          colorFormat)
{
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexColor(mesh);
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        const auto& c = mesh.vertex(v).color();
        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 appendDuplicateVertexQualityToBuffer(
    const MeshType&        mesh,
    const std::list<uint>& vertsToDuplicate,
    auto*                  buffer)
{
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexQuality(mesh);
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        buffer[i] = mesh.vertex(v).quality();
        ++i;
    }
}
 
template<MeshConcept MeshType>
void appendDuplicateVertexTexCoordsToBuffer(
    const MeshType&        mesh,
    const std::list<uint>& vertsToDuplicate,
    auto*                  buffer,
    MatrixStorageType      storage = MatrixStorageType::ROW_MAJOR)
{
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexTexCoord(mesh);
 
    const uint VERT_NUM = mesh.vertexNumber() + vertsToDuplicate.size();
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        const auto& t = mesh.vertex(v).texCoord();
        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 appendDuplicateVertexTexCoordIndicesToBuffer(
    const MeshType&        mesh,
    const std::list<uint>& vertsToDuplicate,
    auto*                  buffer)
{
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexTexCoord(mesh);
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        buffer[i] = mesh.vertex(v).texCoord().index();
        ++i;
    }
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_IMPORT_EXPORT_APPEND_REPLACE_TO_BUFFER_H