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 "detail.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)
{
    using namespace detail;
 
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    const uint ROW_NUM = mesh.vertexNumber() + vertsToDuplicate.size();
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        const auto& pos = mesh.vertex(v).position();
 
        at(buffer, i, 0, ROW_NUM, 3, storage) = pos.x();
        at(buffer, i, 1, ROW_NUM, 3, storage) = pos.y();
        at(buffer, i, 2, ROW_NUM, 3, storage) = pos.z();
 
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void replaceFaceVertexIndicesByVertexDuplicationToBuffer(
    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)
{
    using namespace detail;
 
    // no vertices have been duplicated, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    assert(vertsToDuplicate.size() == facesToReassign.size());
 
    const uint ROW_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) {
            at(buffer, f.first, f.second, ROW_NUM, largestFaceSize, storage) =
                vi;
        }
        ++vi;
    }
}
 
template<FaceMeshConcept MeshType>
void replaceTriangulatedFaceVertexIndicesByVertexDuplicationToBuffer(
    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)
{
    using namespace detail;
 
    // 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 ROW_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
                    auto& triVert = at(buffer, t, j, ROW_NUM, 3, storage);
                    if (triVert == vert) {
                        triVert = 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)
{
    using namespace detail;
 
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexNormal(mesh);
 
    const uint ROW_NUM = mesh.vertexNumber() + vertsToDuplicate.size();
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        const auto& normal                    = mesh.vertex(v).normal();
        at(buffer, i, 0, ROW_NUM, 3, storage) = normal.x();
        at(buffer, i, 1, ROW_NUM, 3, storage) = normal.y();
        at(buffer, i, 2, ROW_NUM, 3, storage) = 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)
{
    using namespace detail;
 
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexColor(mesh);
 
    const bool R_INT   = representation == Color::Representation::INT_0_255;
    const uint ROW_NUM = mesh.vertexNumber() + vertsToDuplicate.size();
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        const auto& c                         = mesh.vertex(v).color();
        at(buffer, i, 0, ROW_NUM, 4, storage) = R_INT ? c.red() : c.redF();
        at(buffer, i, 1, ROW_NUM, 4, storage) = R_INT ? c.green() : c.greenF();
        at(buffer, i, 2, ROW_NUM, 4, storage) = R_INT ? c.blue() : c.blueF();
        at(buffer, i, 3, ROW_NUM, 4, storage) = 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)
{
    using namespace detail;
 
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexTexCoord(mesh);
 
    const uint ROW_NUM = mesh.vertexNumber() + vertsToDuplicate.size();
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        const auto& t                         = mesh.vertex(v).texCoord();
        at(buffer, i, 0, ROW_NUM, 2, storage) = t.u();
        at(buffer, i, 1, ROW_NUM, 2, storage) = t.v();
 
        ++i;
    }
}
 
template<MeshConcept MeshType>
void appendDuplicateVertexTangentsToBuffer(
    const MeshType&        mesh,
    const std::list<uint>& vertsToDuplicate,
    auto*                  buffer,
    bool                   storeHandednessAsW = true,
    MatrixStorageType      storage            = MatrixStorageType::ROW_MAJOR)
{
    using namespace detail;
 
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexTangent(mesh);
 
    const uint ROW_NUM = mesh.vertexNumber() + vertsToDuplicate.size();
    const uint COL_NUM = storeHandednessAsW ? 4 : 3;
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        const auto& t = mesh.vertex(v).tangent();
 
        at(buffer, i, 0, ROW_NUM, COL_NUM, storage) = t.x();
        at(buffer, i, 1, ROW_NUM, COL_NUM, storage) = t.y();
        at(buffer, i, 2, ROW_NUM, COL_NUM, storage) = t.z();
        if (storeHandednessAsW) {
            at(buffer, i, 3, ROW_NUM, COL_NUM, storage) =
                mesh.vertex(v).tangentRightHanded() ? 1.0 : -1.0;
        }
 
        ++i;
    }
}
 
template<MeshConcept MeshType>
void appendDuplicateVertexMaterialIndicesToBuffer(
    const MeshType&        mesh,
    const std::list<uint>& vertsToDuplicate,
    auto*                  buffer)
{
    // no vertices to duplicate, do nothing
    if (vertsToDuplicate.empty())
        return;
 
    requirePerVertexMaterialIndex(mesh);
 
    for (uint i = mesh.vertexNumber(); const auto& v : vertsToDuplicate) {
        buffer[i] = mesh.vertex(v).materialIndex();
        ++i;
    }
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_IMPORT_EXPORT_APPEND_REPLACE_TO_BUFFER_H