gltfmeshbuilder.cpp

Go to the documentation of this file.

// Copyright (C) 2026 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:critical reason:data-parser
 
#include "gltfmeshbuilder.h"
 
#include <QtQuick3DGltf/private/qssggltfaccessorreader_p.h>
#include <QtQuick3DGltf/private/qssggltfparser_p.h>
 
#include <QtGui/qvector2d.h>
#include <QtGui/qvector3d.h>
#include <QtGui/qvector4d.h>
 
QT_BEGIN_NAMESPACE
 
using namespace QSSGGltf;
 
namespace GltfMeshBuilder {
 
namespace {
 
struct IntVector4D {
    qint32 x = 0;
    qint32 y = 0;
    qint32 z = 0;
    qint32 w = 0;
};
 
struct MorphTargetData {
    QVector<QVector3D> positions;
    QVector<QVector3D> normals;
    QVector<QVector3D> tangents;
};
 
struct PrimitiveData {
    QVector<quint32> indexes; // triangle list, relative to this primitive's vertices
    QVector<QVector3D> positions;
    QVector<QVector3D> normals;
    QVector<QVector3D> tangents;
    QVector<QVector3D> binormals;
    QVector<QVector2D> uv0;
    QVector<QVector2D> uv1;
    QVector<QVector4D> colors;
    QVector<IntVector4D> joints;
    QVector<QVector4D> weights;
    QVector<MorphTargetData> targets;
    QString materialName;
};
 
struct Requirements {
    bool needsNormals = false;
    bool needsTangents = false;
    bool needsUV0 = false;
    bool needsUV1 = false;
    bool needsColors = false;
    bool needsJoints = false;
    int numMorphTargets = 0;
    bool needsTargetPositions = false;
    bool needsTargetNormals = false;
    bool needsTargetTangents = false;
 
    void collect(const PrimitiveData &primitive)
    {
        needsNormals |= !primitive.normals.isEmpty();
        needsTangents |= !primitive.tangents.isEmpty();
        needsUV0 |= !primitive.uv0.isEmpty();
        needsUV1 |= !primitive.uv1.isEmpty();
        needsColors |= !primitive.colors.isEmpty();
        needsJoints |= !primitive.joints.isEmpty();
        numMorphTargets = qMax(numMorphTargets, int(primitive.targets.size()));
        for (const MorphTargetData &target : primitive.targets) {
            needsTargetPositions |= !target.positions.isEmpty();
            needsTargetNormals |= !target.normals.isEmpty();
            needsTargetTangents |= !target.tangents.isEmpty();
        }
    }
};
 
// Drops degenerate strip triangles and an incomplete trailing triangle
QVector<quint32> toTriangleList(int mode, QVector<quint32> indexes)
{
    if (mode == MeshPrimitive::Triangles) {
        if (const qsizetype excess = indexes.size() % 3) {
            qCWarning(lcQuick3DGltf) << "Triangle list has" << indexes.size()
                                     << "indices, which is not a multiple of 3";
            indexes.resize(indexes.size() - excess);
        }
        return indexes;
    }
 
    QVector<quint32> result;
    if (mode == MeshPrimitive::TriangleStrip) {
        result.reserve(qMax(0, (indexes.size() - 2)) * 3);
        for (qsizetype i = 0; i + 2 < indexes.size(); ++i) {
            quint32 a = indexes[i], b = indexes[i + 1], c = indexes[i + 2];
            if (i % 2)
                std::swap(a, b);
            if (a == b || b == c || a == c)
                continue;
            result << a << b << c;
        }
    } else if (mode == MeshPrimitive::TriangleFan) {
        result.reserve(qMax(0, (indexes.size() - 2)) * 3);
        for (qsizetype i = 1; i + 1 < indexes.size(); ++i)
            result << indexes[0] << indexes[i] << indexes[i + 1];
    }
    return result;
}
 
template<typename Vec>
QVector<Vec> toVectors(const QList<float> &floats, int components)
{
    QVector<Vec> result;
    const qsizetype count = floats.size() / components;
    result.reserve(count);
    for (qsizetype i = 0; i < count; ++i) {
        Vec v;
        for (int c = 0; c < qMin(components, int(sizeof(Vec) / sizeof(float))); ++c)
            v[c] = floats[i * components + c];
        result.append(v);
    }
    return result;
}
 
template<typename T>
QVector<T> deindex(const QVector<T> &data, const QVector<quint32> &indexes)
{
    if (data.isEmpty())
        return {};
    QVector<T> result;
    result.reserve(indexes.size());
    for (const quint32 index : indexes)
        result.append(data.value(index));
    return result;
}
 
// Expands the primitive so every triangle has unique vertices
void deindexPrimitive(PrimitiveData &primitive)
{
    primitive.positions = deindex(primitive.positions, primitive.indexes);
    primitive.normals = deindex(primitive.normals, primitive.indexes);
    primitive.tangents = deindex(primitive.tangents, primitive.indexes);
    primitive.binormals = deindex(primitive.binormals, primitive.indexes);
    primitive.uv0 = deindex(primitive.uv0, primitive.indexes);
    primitive.uv1 = deindex(primitive.uv1, primitive.indexes);
    primitive.colors = deindex(primitive.colors, primitive.indexes);
    primitive.joints = deindex(primitive.joints, primitive.indexes);
    primitive.weights = deindex(primitive.weights, primitive.indexes);
    for (MorphTargetData &target : primitive.targets) {
        target.positions = deindex(target.positions, primitive.indexes);
        target.normals = deindex(target.normals, primitive.indexes);
        target.tangents = deindex(target.tangents, primitive.indexes);
    }
    std::iota(primitive.indexes.begin(), primitive.indexes.end(), 0);
}
 
void generateNormals(PrimitiveData &primitive, bool smooth)
{
    if (!smooth) {
        // Flat normals need per-face vertices
        deindexPrimitive(primitive);
    }
 
    primitive.normals.fill(QVector3D(), primitive.positions.size());
    for (qsizetype i = 0; i + 2 < primitive.indexes.size(); i += 3) {
        const quint32 i0 = primitive.indexes[i], i1 = primitive.indexes[i + 1], i2 = primitive.indexes[i + 2];
        const QVector3D faceNormal = QVector3D::crossProduct(primitive.positions[i1] - primitive.positions[i0],
                                                             primitive.positions[i2] - primitive.positions[i0]);
        // Area weighted
        primitive.normals[i0] += faceNormal;
        primitive.normals[i1] += faceNormal;
        primitive.normals[i2] += faceNormal;
    }
    for (QVector3D &normal : primitive.normals)
        normal.normalize();
}
 
// Per corner, since a UV mirror seam gives a vertex two tangents
void generateTangents(PrimitiveData &primitive)
{
    if (primitive.uv0.isEmpty() || primitive.normals.isEmpty())
        return;
    deindexPrimitive(primitive);
 
    const qsizetype cornerCount = primitive.indexes.size();
    if (cornerCount == 0)
        return;
 
    // xyz tangent, w bitangent sign
    QVector<float> generated(cornerCount * 4);
    QSSGMesh::generateTangents(generated.data(), primitive.indexes.constData(), size_t(cornerCount),
                               reinterpret_cast<const float *>(primitive.positions.constData()),
                               size_t(primitive.positions.size()), sizeof(QVector3D),
                               reinterpret_cast<const float *>(primitive.normals.constData()), sizeof(QVector3D),
                               reinterpret_cast<const float *>(primitive.uv0.constData()), sizeof(QVector2D));
 
    primitive.tangents.resize(cornerCount);
    primitive.binormals.resize(cornerCount);
    for (qsizetype i = 0; i < cornerCount; ++i) {
        const float *t = generated.constData() + i * 4;
        const QVector3D tangent(t[0], t[1], t[2]);
        primitive.tangents[i] = tangent;
        primitive.binormals[i] = QVector3D::crossProduct(primitive.normals.at(i), tangent) * t[3];
    }
}
 
bool materialNeedsTangents(const QSSGGltfDocument &document, int materialIndex)
{
    if (materialIndex < 0 || materialIndex >= document.materials.size())
        return false;
    const Material &material = document.materials.at(materialIndex);
    // Anisotropy needs a tangent frame that follows the UVs
    return material.normalTexture.isSet()
            || (material.clearcoat && material.clearcoat->clearcoatNormalTexture.isSet())
            || (material.anisotropy && material.anisotropy->anisotropyStrength > 0.0f);
}
 
// Equivalent of Assimp's joinIdenticalVertices
void weldVertices(PrimitiveData &primitive)
{
    const qsizetype vertexCount = primitive.positions.size();
    if (vertexCount == 0)
        return;
 
    QVarLengthArray<QSSGMesh::MeshVertexStream, 16> streams;
    const auto addStream = [&](const auto &data) {
        using Element = std::decay_t<decltype(*data.constData())>;
        if (!data.isEmpty())
            streams.append({ data.constData(), sizeof(Element), sizeof(Element) });
    };
    addStream(primitive.positions);
    addStream(primitive.normals);
    addStream(primitive.tangents);
    addStream(primitive.binormals);
    addStream(primitive.uv0);
    addStream(primitive.uv1);
    addStream(primitive.colors);
    addStream(primitive.joints);
    addStream(primitive.weights);
    for (const MorphTargetData &target : std::as_const(primitive.targets)) {
        addStream(target.positions);
        addStream(target.normals);
        addStream(target.tangents);
    }
 
    // Welding is only an optimization, so skip it instead
    if (size_t(streams.size()) > QSSGMesh::maxVertexStreams) {
        qCWarning(lcQuick3DGltf) << "Not welding vertices for a mesh with" << streams.size()
                                 << "attribute streams; at most" << QSSGMesh::maxVertexStreams
                                 << "are supported";
        return;
    }
 
    QVector<unsigned int> remap(vertexCount);
    const size_t uniqueCount = QSSGMesh::generateVertexRemap(remap.data(), primitive.indexes.constData(),
                                                             primitive.indexes.size(), vertexCount,
                                                             streams.constData(), streams.size());
    if (qsizetype(uniqueCount) == vertexCount)
        return;
 
    const auto remapStream = [&](auto &data) {
        using Element = std::decay_t<decltype(*data.constData())>;
        if (data.isEmpty())
            return;
        QVector<Element> welded(uniqueCount);
        QSSGMesh::remapVertexBuffer(welded.data(), data.constData(), vertexCount, sizeof(Element), remap.constData());
        data = std::move(welded);
    };
    remapStream(primitive.positions);
    remapStream(primitive.normals);
    remapStream(primitive.tangents);
    remapStream(primitive.binormals);
    remapStream(primitive.uv0);
    remapStream(primitive.uv1);
    remapStream(primitive.colors);
    remapStream(primitive.joints);
    remapStream(primitive.weights);
    for (MorphTargetData &target : primitive.targets) {
        remapStream(target.positions);
        remapStream(target.normals);
        remapStream(target.tangents);
    }
 
    QSSGMesh::remapIndexBuffer(primitive.indexes.data(), primitive.indexes.constData(),
                               primitive.indexes.size(), remap.constData());
}
 
bool loadPrimitive(const QSSGGltfDocument &document, const MeshPrimitive &source,
                   const GltfSceneConverter::Options &options, PrimitiveData &primitive)
{
    const int positionAccessor = source.attributes.value(QByteArrayLiteral("POSITION"), -1);
    if (positionAccessor < 0) {
        qCWarning(lcQuick3DGltf) << "Skipping primitive without POSITION data";
        return false;
    }
 
    primitive.positions = toVectors<QVector3D>(QSSGGltfAccessorReader::readAsFloats(document, positionAccessor), 3);
    const qsizetype vertexCount = primitive.positions.size();
 
    // Indices; non-indexed primitives get a sequential index buffer
    QVector<quint32> indexes;
    if (source.indices >= 0) {
        indexes = QVector<quint32>(QSSGGltfAccessorReader::readIndices(document, source.indices));
    } else {
        indexes.resize(vertexCount);
        std::iota(indexes.begin(), indexes.end(), 0);
    }
    primitive.indexes = toTriangleList(source.mode, std::move(indexes));
    if (primitive.indexes.isEmpty()) {
        if (source.mode != MeshPrimitive::Triangles && source.mode != MeshPrimitive::TriangleStrip
            && source.mode != MeshPrimitive::TriangleFan) {
            qCWarning(lcQuick3DGltf) << "Skipping primitive with unsupported mode" << source.mode
                                     << "(points and lines are not supported)";
        }
        return false;
    }
 
    // Everything below indexes the vertex data directly
    for (const quint32 index : std::as_const(primitive.indexes)) {
        if (qsizetype(index) >= vertexCount) {
            qCWarning(lcQuick3DGltf) << "Skipping primitive with out-of-range index value" << index;
            return false;
        }
    }
 
    // TANGENT needs the normals, so NORMAL comes first
    static const QByteArray knownSemantics[] = {
        QByteArrayLiteral("POSITION"),   QByteArrayLiteral("NORMAL"),    QByteArrayLiteral("TANGENT"),
        QByteArrayLiteral("TEXCOORD_0"), QByteArrayLiteral("TEXCOORD_1"), QByteArrayLiteral("COLOR_0"),
        QByteArrayLiteral("JOINTS_0"),   QByteArrayLiteral("WEIGHTS_0"),
    };
    for (auto it = source.attributes.constBegin(); it != source.attributes.constEnd(); ++it) {
        if (std::find(std::begin(knownSemantics), std::end(knownSemantics), it.key()) == std::end(knownSemantics)) {
            qCWarning(lcQuick3DGltf) << "Ignoring unsupported vertex attribute" << it.key();
        }
    }
 
    for (const QByteArray &semantic : knownSemantics) {
        const int accessorIndex = source.attributes.value(semantic, -1);
        if (accessorIndex < 0 || accessorIndex >= document.accessors.size())
            continue;
        const Accessor &accessor = document.accessors.at(accessorIndex);
        const auto floats = [&] { return QSSGGltfAccessorReader::readAsFloats(document, accessorIndex); };
 
        if (semantic == QByteArrayLiteral("POSITION")) {
            // already read
        } else if (semantic == QByteArrayLiteral("NORMAL")) {
            primitive.normals = toVectors<QVector3D>(floats(), 3);
        } else if (semantic == QByteArrayLiteral("TANGENT")) {
            // The specification requires ignoring tangents without normals
            if (primitive.normals.isEmpty())
                continue;
            // xyz tangent, w handedness
            const QList<float> data = floats();
            const qsizetype count = data.size() / 4;
            primitive.tangents.reserve(count);
            primitive.binormals.reserve(count);
            for (qsizetype i = 0; i < count; ++i) {
                const QVector3D tangent(data[i * 4], data[i * 4 + 1], data[i * 4 + 2]);
                const float handedness = data[i * 4 + 3];
                primitive.tangents.append(tangent);
                const QVector3D normal = primitive.normals.value(i);
                primitive.binormals.append(QVector3D::crossProduct(normal, tangent) * handedness);
            }
        } else if (semantic == QByteArrayLiteral("TEXCOORD_0") || semantic == QByteArrayLiteral("TEXCOORD_1")) {
            // glTF UV origin is top-left, Qt Quick 3D bottom-left
            auto uv = toVectors<QVector2D>(floats(), Accessor::componentCount(accessor.type));
            for (QVector2D &coord : uv)
                coord.setY(1.0f - coord.y());
            if (semantic == QByteArrayLiteral("TEXCOORD_0"))
                primitive.uv0 = std::move(uv);
            else
                primitive.uv1 = std::move(uv);
        } else if (semantic == QByteArrayLiteral("COLOR_0")) {
            const int components = Accessor::componentCount(accessor.type);
            if (components == 3) {
                const QList<float> data = floats();
                const qsizetype count = data.size() / 3;
                primitive.colors.reserve(count);
                for (qsizetype i = 0; i < count; ++i)
                    primitive.colors.append(QVector4D(data[i * 3], data[i * 3 + 1], data[i * 3 + 2], 1.0f));
            } else {
                primitive.colors = toVectors<QVector4D>(floats(), 4);
            }
        } else if (semantic == QByteArrayLiteral("JOINTS_0")) {
            const QList<float> data = floats();
            const qsizetype count = data.size() / 4;
            primitive.joints.reserve(count);
            // Also maps NaN, whose cast would be undefined, to 0
            const auto toJointIndex = [](float value) {
                return value >= 0.0f && value < 2.0e9f ? qint32(value) : 0;
            };
            for (qsizetype i = 0; i < count; ++i) {
                primitive.joints.append({ toJointIndex(data[i * 4]), toJointIndex(data[i * 4 + 1]),
                                          toJointIndex(data[i * 4 + 2]), toJointIndex(data[i * 4 + 3]) });
            }
        } else if (semantic == QByteArrayLiteral("WEIGHTS_0")) {
            auto weights = toVectors<QVector4D>(floats(), 4);
            // Renormalize so the four influences sum to one
            for (QVector4D &weight : weights) {
                const float sum = weight.x() + weight.y() + weight.z() + weight.w();
                if (!qFuzzyIsNull(sum) && !qFuzzyCompare(sum, 1.0f))
                    weight /= sum;
            }
            primitive.weights = std::move(weights);
        }
    }
 
    // The renderer supports at most 8 morph targets
    constexpr int maxMorphTargets = 8;
    if (source.targets.size() > maxMorphTargets) {
        qCWarning(lcQuick3DGltf) << "Mesh primitive has" << source.targets.size()
                                 << "morph targets, only the first" << maxMorphTargets << "are used";
    }
    const qsizetype targetCount = qMin(qsizetype(maxMorphTargets), source.targets.size());
    for (qsizetype targetIndex = 0; targetIndex < targetCount; ++targetIndex) {
        const QHash<QByteArray, int> &sourceTarget = source.targets.at(targetIndex);
        MorphTargetData target;
        if (const int accessor = sourceTarget.value(QByteArrayLiteral("POSITION"), -1); accessor >= 0)
            target.positions = toVectors<QVector3D>(QSSGGltfAccessorReader::readAsFloats(document, accessor), 3);
        if (const int accessor = sourceTarget.value(QByteArrayLiteral("NORMAL"), -1); accessor >= 0)
            target.normals = toVectors<QVector3D>(QSSGGltfAccessorReader::readAsFloats(document, accessor), 3);
        if (const int accessor = sourceTarget.value(QByteArrayLiteral("TANGENT"), -1); accessor >= 0)
            target.tangents = toVectors<QVector3D>(QSSGGltfAccessorReader::readAsFloats(document, accessor), 3);
        primitive.targets.append(target);
    }
 
    // Everything below relies on matching attribute counts
    const auto normalizeCount = [vertexCount](auto &data, const char *what) {
        if (!data.isEmpty() && data.size() != vertexCount) {
            qCWarning(lcQuick3DGltf) << what << "data has" << data.size() << "elements, expected" << vertexCount;
            data.resize(vertexCount);
        }
    };
    normalizeCount(primitive.normals, "NORMAL");
    normalizeCount(primitive.tangents, "TANGENT");
    normalizeCount(primitive.binormals, "TANGENT");
    normalizeCount(primitive.uv0, "TEXCOORD_0");
    normalizeCount(primitive.uv1, "TEXCOORD_1");
    normalizeCount(primitive.colors, "COLOR_0");
    normalizeCount(primitive.joints, "JOINTS_0");
    normalizeCount(primitive.weights, "WEIGHTS_0");
    for (MorphTargetData &target : primitive.targets) {
        normalizeCount(target.positions, "morph target POSITION");
        normalizeCount(target.normals, "morph target NORMAL");
        normalizeCount(target.tangents, "morph target TANGENT");
    }
 
    if (primitive.normals.isEmpty())
        generateNormals(primitive, options.generateSmoothNormals);
 
    // Switchable variants need tangents if any of their materials does
    const auto anyVariantNeedsTangents = [&] {
        if (!options.materialVariant.isEmpty() || document.materialVariants.isEmpty())
            return false;
        for (const MeshPrimitive::VariantMapping &mapping : source.variantMappings) {
            if (materialNeedsTangents(document, mapping.material))
                return true;
        }
        return false;
    };
    if (primitive.tangents.isEmpty()
        && (options.forceTangentGeneration
            || materialNeedsTangents(document, source.effectiveMaterial(options.materialVariantIndex))
            || anyVariantNeedsTangents())) {
        generateTangents(primitive);
    }
 
    // glTF targets are deltas, the renderer expects absolute values
    for (MorphTargetData &target : primitive.targets) {
        for (qsizetype i = 0; i < target.positions.size() && i < primitive.positions.size(); ++i)
            target.positions[i] += primitive.positions.at(i);
        for (qsizetype i = 0; i < target.normals.size() && i < primitive.normals.size(); ++i)
            target.normals[i] += primitive.normals.at(i);
        for (qsizetype i = 0; i < target.tangents.size() && i < primitive.tangents.size(); ++i)
            target.tangents[i] += primitive.tangents.at(i);
    }
 
    if (options.joinIdenticalVertices)
        weldVertices(primitive);
 
    if (const int materialIndex = source.effectiveMaterial(options.materialVariantIndex); materialIndex >= 0)
        primitive.materialName = document.materials.at(materialIndex).name;
 
    QSSGMesh::optimizeVertexCache(primitive.indexes.data(), primitive.indexes.data(),
                                  primitive.indexes.size(), primitive.positions.size());
    return true;
}
 
template<typename T>
void appendVertexData(QByteArray &buffer, const QVector<T> &data, qsizetype vertexCount)
{
    if (!data.isEmpty())
        buffer.append(reinterpret_cast<const char *>(data.constData()), data.size() * sizeof(T));
    // Zero-fill so all attributes cover the same vertex range
    if (data.size() < vertexCount)
        buffer.append((vertexCount - data.size()) * sizeof(T), '\0');
}
 
} // namespace
 
/*!
    \internal
 
    Builds a QSSGMesh::Mesh from the glTF mesh \a mesh in \a document, with
    one subset per triangle primitive. Primitives with non-triangle topology
    that cannot be converted (points and lines) are skipped with a warning.
    Returns an invalid mesh when no primitive could be converted. When
    \a usedPrimitives is given, it receives the indices of the source
    primitives that became subsets, in subset order, so callers can build a
    matching material list. \a morphInfo receives the number of morph targets
    stored in the mesh and which attributes they carry.
*/
QSSGMesh::Mesh buildMesh(const QSSGGltfDocument &document, const QSSGGltf::Mesh &mesh,
                         const GltfSceneConverter::Options &options,
                         QList<int> *usedPrimitives,
                         GltfMorphTargetInfo *morphInfo)
{
    QVector<PrimitiveData> primitives;
    primitives.reserve(mesh.primitives.size());
    Requirements requirements;
    for (qsizetype primitiveIndex = 0; primitiveIndex < mesh.primitives.size(); ++primitiveIndex) {
        PrimitiveData primitive;
        if (loadPrimitive(document, mesh.primitives.at(primitiveIndex), options, primitive)) {
            requirements.collect(primitive);
            primitives.append(std::move(primitive));
            if (usedPrimitives)
                usedPrimitives->append(int(primitiveIndex));
        }
    }
 
    if (primitives.isEmpty())
        return {};
 
    QByteArray indexBufferData;
    QByteArray positionData;
    QByteArray normalData;
    QByteArray tangentData;
    QByteArray binormalData;
    QByteArray uv0Data;
    QByteArray uv1Data;
    QByteArray colorData;
    QByteArray jointData;
    QByteArray weightData;
    // vec3 padded to vec4, one buffer per target and component
    struct TargetBuffers {
        QByteArray positions;
        QByteArray normals;
        QByteArray tangents;
    };
    QVector<TargetBuffers> targetData(requirements.numMorphTargets);
    const auto appendPaddedVec3 = [](QByteArray &buffer, const QVector<QVector3D> &data, qsizetype vertexCount) {
        for (const QVector3D &v : data) {
            const float padded[4] = { v.x(), v.y(), v.z(), 0.0f };
            buffer.append(reinterpret_cast<const char *>(padded), sizeof(padded));
        }
        if (data.size() < vertexCount)
            buffer.append((vertexCount - data.size()) * 4 * sizeof(float), '\0');
    };
    QVector<QSSGMesh::AssetMeshSubset> subsets;
 
    // 32-bit, since Metal needs 4 byte aligned index buffer offsets
    const auto indexType = QSSGMesh::Mesh::ComponentType::UnsignedInt32;
 
    const auto appendCopy = [](auto &data, qsizetype sourceIndex) {
        if (!data.isEmpty())
            data.append(data.at(sourceIndex));
    };
 
    quint32 baseVertex = 0;
    for (PrimitiveData &primitive : primitives) {
        quint32 indexOffset = indexBufferData.size() / QSSGMesh::MeshInternal::byteSizeForComponentType(indexType);
 
        // LOD indexes precede the original ones, lowest quality first
        QVector<QSSGMesh::Mesh::Lod> meshLods;
        QVector<quint32> lodIndexes;
        if (options.generateMeshLODs && !primitive.normals.isEmpty()) {
            QVector<QSSGMesh::MeshVertexSplit> splitVertices;
            const auto lods = QSSGMesh::generateMeshLevelsOfDetail(primitive.positions, primitive.normals,
                                                                   primitive.indexes, splitVertices,
                                                                   options.lodNormalMergeAngle,
                                                                   options.lodNormalSplitAngle);
            // Split vertices are copies with a recalculated normal
            for (const QSSGMesh::MeshVertexSplit &split : splitVertices) {
                primitive.positions.append(primitive.positions.at(split.sourceIndex));
                primitive.normals.append(split.normal);
                appendCopy(primitive.tangents, split.sourceIndex);
                appendCopy(primitive.binormals, split.sourceIndex);
                appendCopy(primitive.uv0, split.sourceIndex);
                appendCopy(primitive.uv1, split.sourceIndex);
                appendCopy(primitive.colors, split.sourceIndex);
                appendCopy(primitive.joints, split.sourceIndex);
                appendCopy(primitive.weights, split.sourceIndex);
                for (MorphTargetData &target : primitive.targets) {
                    appendCopy(target.positions, split.sourceIndex);
                    appendCopy(target.normals, split.sourceIndex);
                    appendCopy(target.tangents, split.sourceIndex);
                }
            }
            for (const QSSGMesh::MeshLevelOfDetail &lodEntry : lods) {
                QSSGMesh::Mesh::Lod lod;
                lod.offset = indexOffset;
                lod.count = lodEntry.indexes.size();
                lod.distance = lodEntry.distance;
                meshLods.prepend(lod);
                indexOffset += lod.count;
                QVector<quint32> currentLodIndexes = lodEntry.indexes;
                QSSGMesh::optimizeVertexCache(currentLodIndexes.data(), currentLodIndexes.data(),
                                              currentLodIndexes.size(), primitive.positions.size());
                lodIndexes += currentLodIndexes;
            }
        }
        const qsizetype vertexCount = primitive.positions.size();
 
        QVector<quint32> globalIndexes = lodIndexes + primitive.indexes;
        primitive.indexes.clear();
        for (quint32 &index : globalIndexes)
            index += baseVertex;
        indexBufferData.append(reinterpret_cast<const char *>(globalIndexes.constData()),
                               globalIndexes.size() * sizeof(quint32));
        const quint32 subsetIndexCount = globalIndexes.size() - lodIndexes.size();
 
        appendVertexData(positionData, primitive.positions, vertexCount);
        if (requirements.needsNormals)
            appendVertexData(normalData, primitive.normals, vertexCount);
        if (requirements.needsTangents) {
            appendVertexData(tangentData, primitive.tangents, vertexCount);
            appendVertexData(binormalData, primitive.binormals, vertexCount);
        }
        if (requirements.needsUV0)
            appendVertexData(uv0Data, primitive.uv0, vertexCount);
        if (requirements.needsUV1)
            appendVertexData(uv1Data, primitive.uv1, vertexCount);
        if (requirements.needsColors)
            appendVertexData(colorData, primitive.colors, vertexCount);
        if (requirements.needsJoints) {
            if (options.useFloatJointIndices) {
                QVector<QVector4D> floatJoints;
                floatJoints.reserve(primitive.joints.size());
                for (const IntVector4D &joint : std::as_const(primitive.joints))
                    floatJoints.append(QVector4D(float(joint.x), float(joint.y), float(joint.z), float(joint.w)));
                appendVertexData(jointData, floatJoints, vertexCount);
            } else {
                appendVertexData(jointData, primitive.joints, vertexCount);
            }
            appendVertexData(weightData, primitive.weights, vertexCount);
        }
 
        for (int targetIndex = 0; targetIndex < requirements.numMorphTargets; ++targetIndex) {
            const MorphTargetData target = primitive.targets.value(targetIndex);
            if (requirements.needsTargetPositions)
                appendPaddedVec3(targetData[targetIndex].positions, target.positions, vertexCount);
            if (requirements.needsTargetNormals)
                appendPaddedVec3(targetData[targetIndex].normals, target.normals, vertexCount);
            if (requirements.needsTargetTangents)
                appendPaddedVec3(targetData[targetIndex].tangents, target.tangents, vertexCount);
        }
 
        subsets.append({ primitive.materialName,
                         subsetIndexCount,
                         indexOffset,
                         0, // the builder calculates the bounds from the position data
                         0, 0, // lightmap size hint
                         meshLods });
        baseVertex += vertexCount;
    }
 
    QVector<QSSGMesh::AssetVertexEntry> entries;
    entries.append({ QSSGMesh::MeshInternal::getPositionAttrName(), positionData,
                     QSSGMesh::Mesh::ComponentType::Float32, 3 });
    if (!normalData.isEmpty()) {
        entries.append({ QSSGMesh::MeshInternal::getNormalAttrName(), normalData,
                         QSSGMesh::Mesh::ComponentType::Float32, 3 });
    }
    if (!uv0Data.isEmpty()) {
        entries.append({ QSSGMesh::MeshInternal::getUV0AttrName(), uv0Data,
                         QSSGMesh::Mesh::ComponentType::Float32, 2 });
    }
    if (!uv1Data.isEmpty()) {
        entries.append({ QSSGMesh::MeshInternal::getUV1AttrName(), uv1Data,
                         QSSGMesh::Mesh::ComponentType::Float32, 2 });
    }
    if (!tangentData.isEmpty()) {
        entries.append({ QSSGMesh::MeshInternal::getTexTanAttrName(), tangentData,
                         QSSGMesh::Mesh::ComponentType::Float32, 3 });
        entries.append({ QSSGMesh::MeshInternal::getTexBinormalAttrName(), binormalData,
                         QSSGMesh::Mesh::ComponentType::Float32, 3 });
    }
    if (!colorData.isEmpty()) {
        entries.append({ QSSGMesh::MeshInternal::getColorAttrName(), colorData,
                         QSSGMesh::Mesh::ComponentType::Float32, 4 });
    }
    if (!jointData.isEmpty()) {
        entries.append({ QSSGMesh::MeshInternal::getJointAttrName(), jointData,
                         options.useFloatJointIndices ? QSSGMesh::Mesh::ComponentType::Float32
                                                      : QSSGMesh::Mesh::ComponentType::Int32, 4 });
        entries.append({ QSSGMesh::MeshInternal::getWeightAttrName(), weightData,
                         QSSGMesh::Mesh::ComponentType::Float32, 4 });
    }
 
    // Grouped per target, as Mesh::fromAssetData expects
    int numTargetComps = 0;
    if (requirements.numMorphTargets > 0) {
        numTargetComps = int(requirements.needsTargetPositions) + int(requirements.needsTargetNormals)
                + int(requirements.needsTargetTangents);
        for (int targetIndex = 0; targetIndex < requirements.numMorphTargets; ++targetIndex) {
            if (requirements.needsTargetPositions) {
                entries.append({ QSSGMesh::MeshInternal::getPositionAttrName(), targetData[targetIndex].positions,
                                 QSSGMesh::Mesh::ComponentType::Float32, 3, targetIndex });
            }
            if (requirements.needsTargetNormals) {
                entries.append({ QSSGMesh::MeshInternal::getNormalAttrName(), targetData[targetIndex].normals,
                                 QSSGMesh::Mesh::ComponentType::Float32, 3, targetIndex });
            }
            if (requirements.needsTargetTangents) {
                entries.append({ QSSGMesh::MeshInternal::getTexTanAttrName(), targetData[targetIndex].tangents,
                                 QSSGMesh::Mesh::ComponentType::Float32, 3, targetIndex });
            }
        }
    }
 
    if (morphInfo) {
        morphInfo->count = requirements.numMorphTargets;
        morphInfo->hasPositions = requirements.needsTargetPositions;
        morphInfo->hasNormals = requirements.needsTargetNormals;
        morphInfo->hasTangents = requirements.needsTargetTangents;
    }
 
    return QSSGMesh::Mesh::fromAssetData(entries, indexBufferData, indexType, subsets,
                                         quint32(requirements.numMorphTargets), quint32(numTargetComps));
}
 
} // namespace GltfMeshBuilder
 
QT_END_NAMESPACE