qssgmesh.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:critical reason:data-parser
 
 
#include "qssgmesh_p.h"
 
#include <QtCore/QVector>
#include <QtCore/qhash.h>
#include <QtCore/qvarlengtharray.h>
#include <QtCore/qmath.h>
#include <QtQuick3DUtils/private/qssgdataref_p.h>
#include <QtQuick3DUtils/private/qssglightmapuvgenerator_p.h>
#include <QtQuick3DUtils/private/qssgutils_p.h>
 
#include "meshoptimizer.h"
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
namespace QSSGMesh {
 
// fileId, fileVersion, offset, count
static const size_t MULTI_HEADER_STRUCT_SIZE = 16;
 
// meshOffset, meshId, padding
static const size_t MULTI_ENTRY_STRUCT_SIZE = 16;
 
// fileId, fileVersion, flags, size
static const size_t MESH_HEADER_STRUCT_SIZE = 12;
 
// vertexBuffer, indexBuffer, subsets, joints, drawMode, winding
static const size_t MESH_STRUCT_SIZE = 56;
 
// vertex buffer entry list: nameOffset, componentType, componentCount, offset
static const size_t VERTEX_BUFFER_ENTRY_STRUCT_SIZE = 16;
 
// subset list: count, offset, minXYZ, maxXYZ, nameOffset, nameLength
static const size_t SUBSET_STRUCT_SIZE_V3_V4 = 40;
// subset list: count, offset, minXYZ, maxXYZ, nameOffset, nameLength, lightmapSizeWidth, lightmapSizeHeight
static const size_t SUBSET_STRUCT_SIZE_V5 = 48;
// subset list: count, offset, minXYZ, maxXYZ, nameOffset, nameLength, lightmapSizeWidth, lightmapSizeHeight, lodCount
static const size_t SUBSET_STRUCT_SIZE_V6 = 52;
 
//lod entry: count, offset, distance
static const size_t LOD_STRUCT_SIZE = 12;
 
// joint list: jointID, parentID, invBindPose, localToGlobalBoneSpace
static const size_t JOINT_STRUCT_SIZE = 136;
 
// getSizeOfType() is Q_UNREACHABLE outside its enumeration, so a component type
// from the file has to be checked before it gets there.
// Spelled out so that a new component type fails to compile until handled.
static bool isKnownComponentType(quint32 value)
{
    switch (Mesh::ComponentType(value)) {
    case Mesh::ComponentType::UnsignedInt8:
    case Mesh::ComponentType::Int8:
    case Mesh::ComponentType::UnsignedInt16:
    case Mesh::ComponentType::Int16:
    case Mesh::ComponentType::UnsignedInt32:
    case Mesh::ComponentType::Int32:
    case Mesh::ComponentType::UnsignedInt64:
    case Mesh::ComponentType::Int64:
    case Mesh::ComponentType::Float16:
    case Mesh::ComponentType::Float32:
    case Mesh::ComponentType::Float64:
        return true;
    }
    return false;
}
 
// Bounds a count by the file rather than by a chosen cap, so the limit scales
// with the file and cannot be set wrong.
static bool canRead(QIODevice *device, quint64 count, quint64 itemSize)
{
    quint64 bytes = 0;
    if (qMulOverflow(count, itemSize, &bytes))
        return false;
    const qint64 remaining = device->size() - device->pos();
    return remaining >= 0 && bytes <= quint64(remaining);
}
 
MeshInternal::MultiMeshInfo MeshInternal::readFileHeader(QIODevice *device)
{
    const qint64 multiHeaderStartOffset = device->size() - qint64(MULTI_HEADER_STRUCT_SIZE);
    if (multiHeaderStartOffset < 0) {
        qWarning("Mesh file is too small to hold a header");
        return {};
    }
 
    device->seek(multiHeaderStartOffset);
    QDataStream inputStream(device);
    inputStream.setByteOrder(QDataStream::LittleEndian);
    inputStream.setFloatingPointPrecision(QDataStream::SinglePrecision);
 
    MultiMeshInfo meshFileInfo;
    inputStream >> meshFileInfo.fileId >> meshFileInfo.fileVersion;
 
    if (!meshFileInfo.isValid()) {
        qWarning("Mesh file invalid");
        return {};
    }
 
    quint32 multiEntriesOffset; // unused, the entry list is right before the header
    quint32 meshCount;
    inputStream >> multiEntriesOffset >> meshCount;
 
    // The entry list sits immediately before the header, so it bounds the count.
    if (quint64(meshCount) * MULTI_ENTRY_STRUCT_SIZE > quint64(multiHeaderStartOffset)) {
        qWarning("Mesh file declares %u meshes, which do not fit in it", meshCount);
        return {};
    }
 
    for (quint32 i = 0; i < meshCount; ++i) {
        device->seek(multiHeaderStartOffset
                     - (qint64(MULTI_ENTRY_STRUCT_SIZE) * meshCount)
                     + (qint64(MULTI_ENTRY_STRUCT_SIZE) * i));
        quint64 offset;
        quint32 id;
        inputStream >> offset >> id;
        meshFileInfo.meshEntries.insert(id, offset);
    }
 
    return meshFileInfo;
}
 
void MeshInternal::writeFileHeader(QIODevice *device, const MeshInternal::MultiMeshInfo &meshFileInfo)
{
    QDataStream outputStream(device);
    outputStream.setByteOrder(QDataStream::LittleEndian);
    outputStream.setFloatingPointPrecision(QDataStream::SinglePrecision);
 
    const quint32 multiEntriesOffset = device->pos();
    for (auto it = meshFileInfo.meshEntries.cbegin(), end = meshFileInfo.meshEntries.cend(); it != end; ++it) {
        const quint32 id = it.key();
        const quint64 offset = it.value();
        const quint32 padding = 0;
        outputStream << offset << id << padding;
    }
 
    const quint32 meshCount = meshFileInfo.meshEntries.size();
    outputStream << meshFileInfo.fileId << meshFileInfo.fileVersion << multiEntriesOffset << meshCount;
}
 
quint64 MeshInternal::readMeshData(QIODevice *device, quint64 offset, Mesh *mesh, MeshDataHeader *header)
{
    static char alignPadding[4] = {};
 
    device->seek(offset);
    QDataStream inputStream(device);
    inputStream.setByteOrder(QDataStream::LittleEndian);
    inputStream.setFloatingPointPrecision(QDataStream::SinglePrecision);
 
    inputStream >> header->fileId >> header->fileVersion >> header->flags >> header->sizeInBytes;
    if (!header->isValid()) {
        qWarning() << "Mesh data invalid";
        if (header->fileId == MeshDataHeader::FILE_ID) {
            if (header->fileVersion > MeshDataHeader::FILE_VERSION)
                qWarning() << "File version " << header->fileVersion << " newer than " << MeshDataHeader::FILE_VERSION;
            if (header->fileVersion < MeshDataHeader::LEGACY_MESH_FILE_VERSION)
                qWarning() << "File version " << header->fileVersion << " older than " << MeshDataHeader::LEGACY_MESH_FILE_VERSION;
        } else {
            qWarning() << "Invalid file ID" << header->fileId;
        }
        return 0;
    }
 
    MeshInternal::MeshOffsetTracker offsetTracker(offset + MESH_HEADER_STRUCT_SIZE);
    Q_ASSERT(offsetTracker.offset() == device->pos());
 
    quint32 targetBufferEntriesCount;
    quint32 vertexBufferEntriesCount;
    quint32 targetBufferDataSize;
    quint32 vertexBufferDataSize;
    inputStream >> targetBufferEntriesCount
                >> vertexBufferEntriesCount
                >> mesh->m_vertexBuffer.stride
                >> targetBufferDataSize
                >> vertexBufferDataSize;
 
    if (!header->hasSeparateTargetBuffer()) {
        targetBufferEntriesCount = 0;
        targetBufferDataSize = 0;
    }
 
    quint32 indexBufferComponentType;
    quint32 indexBufferDataOffset;
    quint32 indexBufferDataSize;
    inputStream >> indexBufferComponentType
                >> indexBufferDataOffset
                >> indexBufferDataSize;
    if (!isKnownComponentType(indexBufferComponentType)) {
        qWarning("Mesh index buffer has unknown component type %u", indexBufferComponentType);
        return 0;
    }
    mesh->m_indexBuffer.componentType = Mesh::ComponentType(indexBufferComponentType);
 
    quint32 targetCount;
    quint32 subsetsCount;
    inputStream >> targetCount >> subsetsCount;
    // Before version 7 this field is a leftover subset offset, not a count;
    // the legacy path below works the count out from the attribute names.
    if (header->hasSeparateTargetBuffer())
        mesh->m_targetBuffer.numTargets = targetCount;
 
    quint32 jointsOffsets; // unused, see the format documentation
    quint32 jointsCount;
    inputStream >> jointsOffsets >> jointsCount;
    quint32 drawMode;
    quint32 winding;
    inputStream >> drawMode >> winding;
    mesh->m_drawMode = Mesh::DrawMode(drawMode);
    mesh->m_winding = Mesh::Winding(winding);
 
    offsetTracker.advance(MESH_STRUCT_SIZE);
 
    if (!canRead(device, vertexBufferEntriesCount, VERTEX_BUFFER_ENTRY_STRUCT_SIZE)) {
        qWarning("Mesh declares %u vertex buffer entries, which do not fit in the file",
                 vertexBufferEntriesCount);
        return 0;
    }
 
    quint32 entriesByteSize = 0;
    for (quint32 i = 0; i < vertexBufferEntriesCount; ++i) {
        Mesh::VertexBufferEntry vertexBufferEntry;
        quint32 componentType;
        quint32 nameOffset; // unused
        inputStream >> nameOffset
                    >> componentType
                    >> vertexBufferEntry.componentCount
                    >> vertexBufferEntry.offset;
        if (!isKnownComponentType(componentType)) {
            qWarning("Mesh attribute %u has unknown component type %u", i, componentType);
            return 0;
        }
        vertexBufferEntry.componentType = Mesh::ComponentType(componentType);
        mesh->m_vertexBuffer.entries.append(vertexBufferEntry);
        entriesByteSize += VERTEX_BUFFER_ENTRY_STRUCT_SIZE;
    }
    quint32 alignAmount = offsetTracker.alignedAdvance(entriesByteSize);
    if (alignAmount)
        device->read(alignPadding, alignAmount);
 
    // vertex buffer entry names
    quint32 numTargets = 0;
    // used for recording the target attributes supported by the mesh
    // and re-construting it when meeting attr_unsupported
    QList<QByteArray> attrNames;
    for (auto &entry : mesh->m_vertexBuffer.entries) {
        quint32 nameLength;
        inputStream >> nameLength;
        offsetTracker.advance(sizeof(quint32));
        if (!canRead(device, nameLength, 1)) {
            qWarning("Mesh declares a %u byte attribute name, which does not fit in the file",
                     nameLength);
            return 0;
        }
        const QByteArray nameWithZeroTerminator = device->read(nameLength);
        entry.name = QByteArray(nameWithZeroTerminator.constData(), qMax(0, nameWithZeroTerminator.size() - 1));
        alignAmount = offsetTracker.alignedAdvance(nameLength);
        if (alignAmount)
            device->read(alignPadding, alignAmount);
        // Old morph meshes' target attributes were appended sequentially
        // behind vertex attributes. However, since the number of targets are restricted by 8
        // the other attributes were named by "attr_unsupported"
        // So just checking numTargets is safe with the above assumption and
        // it will try to reconstruct the unsupported attributes.
        if (numTargets > 0 || (!header->hasSeparateTargetBuffer() && entry.name.startsWith("attr_t"))) {
            // Any later name lands here once a target has been seen, including
            // short ones, and sliced() asserts where mid() would not.
            const QByteArray suffix = entry.name.size() > 6 ? entry.name.sliced(6) : QByteArray();
            if (suffix.startsWith("pos")) {
                const quint32 targetId = entry.name.mid(9).toUInt();
                // All the attributes of the first target should be recorded correctly.
                if (targetId == 0)
                    attrNames.append(MeshInternal::getPositionAttrName());
                numTargets = qMax(numTargets, targetId + 1);
                entry.name = MeshInternal::getPositionAttrName();
                mesh->m_targetBuffer.entries.append(entry);
                targetBufferEntriesCount++;
            } else if (suffix.startsWith("norm")) {
                const quint32 targetId = entry.name.mid(10).toUInt();
                if (targetId == 0)
                    attrNames.append(MeshInternal::getNormalAttrName());
                numTargets = qMax(numTargets, targetId + 1);
                entry.name = MeshInternal::getNormalAttrName();
                mesh->m_targetBuffer.entries.append(entry);
                targetBufferEntriesCount++;
            } else if (suffix.startsWith("tan")) {
                const quint32 targetId = entry.name.mid(9).toUInt();
                if (targetId == 0)
                    attrNames.append(MeshInternal::getTexTanAttrName());
                numTargets = qMax(numTargets, targetId + 1);
                entry.name = MeshInternal::getTexTanAttrName();
                mesh->m_targetBuffer.entries.append(entry);
                targetBufferEntriesCount++;
            } else if (suffix.startsWith("binorm")) {
                const quint32 targetId = entry.name.mid(12).toUInt();
                if (targetId == 0)
                    attrNames.append(MeshInternal::getTexBinormalAttrName());
                numTargets = qMax(numTargets, targetId + 1);
                entry.name = MeshInternal::getTexBinormalAttrName();
                mesh->m_targetBuffer.entries.append(entry);
                targetBufferEntriesCount++;
            } else if (entry.name.startsWith("attr_unsupported")) {
                // Reconstruct, if target 0 recorded a layout to do it from.
                if (attrNames.isEmpty()) {
                    qWarning("Mesh has an unsupported morph target attribute with no target 0 to "
                             "take the layout from");
                    return 0;
                }
                entry.name = attrNames[targetBufferEntriesCount % attrNames.size()];
                mesh->m_targetBuffer.entries.append(entry);
                targetBufferEntriesCount++;
            }
        }
    }
 
    if (!canRead(device, vertexBufferDataSize, 1)) {
        qWarning("Mesh declares %u bytes of vertex data, which do not fit in the file",
                 vertexBufferDataSize);
        return 0;
    }
    mesh->m_vertexBuffer.data = device->read(vertexBufferDataSize);
    alignAmount = offsetTracker.alignedAdvance(vertexBufferDataSize);
    if (alignAmount)
        device->read(alignPadding, alignAmount);
 
    if (!canRead(device, indexBufferDataSize, 1)) {
        qWarning("Mesh declares %u bytes of index data, which do not fit in the file",
                 indexBufferDataSize);
        return 0;
    }
    mesh->m_indexBuffer.data = device->read(indexBufferDataSize);
    alignAmount = offsetTracker.alignedAdvance(indexBufferDataSize);
    if (alignAmount)
        device->read(alignPadding, alignAmount);
 
    const size_t subsetStructSize = header->hasLodDataHint() ? SUBSET_STRUCT_SIZE_V6
            : header->hasLightmapSizeHint()                   ? SUBSET_STRUCT_SIZE_V5
                                                              : SUBSET_STRUCT_SIZE_V3_V4;
    if (!canRead(device, subsetsCount, subsetStructSize)) {
        qWarning("Mesh declares %u subsets, which do not fit in the file", subsetsCount);
        return 0;
    }
 
    quint32 subsetByteSize = 0;
    QVector<MeshInternal::Subset> internalSubsets;
    for (quint32 i = 0; i < subsetsCount; ++i) {
        MeshInternal::Subset subset;
        float minX;
        float minY;
        float minZ;
        float maxX;
        float maxY;
        float maxZ;
        quint32 nameOffset; // unused
        inputStream >> subset.count
                    >> subset.offset
                    >> minX
                    >> minY
                    >> minZ
                    >> maxX
                    >> maxY
                    >> maxZ
                    >> nameOffset
                    >> subset.nameLength;
        subset.bounds.min = QVector3D(minX, minY, minZ);
        subset.bounds.max = QVector3D(maxX, maxY, maxZ);
        if (header->hasLightmapSizeHint()) {
            quint32 width = 0;
            quint32 height = 0;
            inputStream >> width >> height;
            subset.lightmapSizeHint = QSize(width, height);
            if (header->hasLodDataHint()) {
                quint32 lodCount = 0;
                inputStream >> lodCount;
                subset.lodCount = lodCount;
                subsetByteSize += SUBSET_STRUCT_SIZE_V6;
            } else {
                subsetByteSize += SUBSET_STRUCT_SIZE_V5;
            }
        } else {
            subset.lightmapSizeHint = QSize(0, 0);
            subsetByteSize += SUBSET_STRUCT_SIZE_V3_V4;
        }
        internalSubsets.append(subset);
 
    }
    alignAmount = offsetTracker.alignedAdvance(subsetByteSize);
    if (alignAmount)
        device->read(alignPadding, alignAmount);
 
    for (MeshInternal::Subset &internalSubset : internalSubsets) {
        if (!canRead(device, internalSubset.nameLength, 2)) {
            qWarning("Mesh subset declares a %u character name, which does not fit in the file",
                     internalSubset.nameLength);
            return 0;
        }
        internalSubset.rawNameUtf16 = device->read(qint64(internalSubset.nameLength) * 2);
        alignAmount = offsetTracker.alignedAdvance(internalSubset.nameLength * 2);
        if (alignAmount)
            device->read(alignPadding, alignAmount);
    }
 
    quint32 lodByteSize = 0;
    for (const MeshInternal::Subset &internalSubset : internalSubsets) {
        // The subsets share these bytes, so check them as they are consumed.
        if (!canRead(device, internalSubset.lodCount, LOD_STRUCT_SIZE)) {
            qWarning("Mesh subset declares %u levels of detail, which do not fit in the file",
                     internalSubset.lodCount);
            return 0;
        }
        auto meshSubset = internalSubset.toMeshSubset();
        // Read Level of Detail data here
        for (auto &lod : meshSubset.lods) {
            quint32 count = 0;
            quint32 offset = 0;
            float distance = 0.0;
            inputStream >> count >> offset >> distance;
            lod.count = count;
            lod.offset = offset;
            lod.distance = distance;
            lodByteSize += LOD_STRUCT_SIZE;
        }
 
        mesh->m_subsets.append(meshSubset);
    }
    alignAmount = offsetTracker.alignedAdvance(lodByteSize);
    if (alignAmount)
        device->read(alignPadding, alignAmount);
 
    // Unused, but the morph target entries come after them.
    if (jointsCount) {
        if (!canRead(device, jointsCount, JOINT_STRUCT_SIZE)) {
            qWarning("Mesh declares %u joints, which do not fit in the file", jointsCount);
            return 0;
        }
        const quint64 jointsByteSize = quint64(jointsCount) * JOINT_STRUCT_SIZE;
        device->seek(device->pos() + qint64(jointsByteSize));
        offsetTracker.advance(qint32(jointsByteSize));
    }
 
    // Data for morphTargets
    if (targetBufferEntriesCount > 0) {
        if (header->hasSeparateTargetBuffer()) {
            if (!canRead(device, targetBufferEntriesCount, VERTEX_BUFFER_ENTRY_STRUCT_SIZE)) {
                qWarning("Mesh declares %u morph target entries, which do not fit in the file",
                         targetBufferEntriesCount);
                return 0;
            }
            entriesByteSize = 0;
            for (quint32 i = 0; i < targetBufferEntriesCount; ++i) {
                Mesh::VertexBufferEntry targetBufferEntry;
                quint32 componentType;
                quint32 nameOffset; // unused
                inputStream >> nameOffset
                            >> componentType
                            >> targetBufferEntry.componentCount
                            >> targetBufferEntry.offset;
                if (!isKnownComponentType(componentType)) {
                    qWarning("Mesh morph target attribute %u has unknown component type %u", i,
                             componentType);
                    return 0;
                }
                targetBufferEntry.componentType = Mesh::ComponentType(componentType);
                mesh->m_targetBuffer.entries.append(targetBufferEntry);
                entriesByteSize += VERTEX_BUFFER_ENTRY_STRUCT_SIZE;
            }
            alignAmount = offsetTracker.alignedAdvance(entriesByteSize);
            if (alignAmount)
                device->read(alignPadding, alignAmount);
 
            for (auto &entry : mesh->m_targetBuffer.entries) {
                quint32 nameLength;
                inputStream >> nameLength;
                offsetTracker.advance(sizeof(quint32));
                if (!canRead(device, nameLength, 1)) {
                    qWarning("Mesh declares a %u byte morph target name, which does not fit in "
                             "the file", nameLength);
                    return 0;
                }
                const QByteArray nameWithZeroTerminator = device->read(nameLength);
                entry.name = QByteArray(nameWithZeroTerminator.constData(), qMax(0, nameWithZeroTerminator.size() - 1));
                alignAmount = offsetTracker.alignedAdvance(nameLength);
                if (alignAmount)
                    device->read(alignPadding, alignAmount);
            }
 
            if (!canRead(device, targetBufferDataSize, 1)) {
                qWarning("Mesh declares %u bytes of morph target data, which do not fit in the "
                         "file", targetBufferDataSize);
                return 0;
            }
            mesh->m_targetBuffer.data = device->read(targetBufferDataSize);
        } else {
            // The target buffer is sized by the product of these two, and the
            // layout has only position, normal, tangent and binormal per target.
            constexpr quint32 maxTargets = 8;
            constexpr quint32 maxComponentsPerTarget = 4;
            if (mesh->m_vertexBuffer.stride == 0 || numTargets == 0
                || numTargets > maxTargets
                || vertexBufferDataSize < mesh->m_vertexBuffer.stride
                || targetBufferEntriesCount > vertexBufferEntriesCount
                || targetBufferEntriesCount < numTargets
                || targetBufferEntriesCount > numTargets * maxComponentsPerTarget) {
                qWarning("Mesh morph target layout is inconsistent: stride %u, %u targets, %u "
                         "entries of %u",
                         mesh->m_vertexBuffer.stride, numTargets, targetBufferEntriesCount,
                         vertexBufferEntriesCount);
                return 0;
            }
            // remove target entries from vertexbuffer entries
            mesh->m_vertexBuffer.entries.remove(vertexBufferEntriesCount - targetBufferEntriesCount,
                                                targetBufferEntriesCount);
            // At least one vertex, so vertexCount - 1 below does not wrap.
            const quint32 vertexCount = vertexBufferDataSize / mesh->m_vertexBuffer.stride;
            // The least an entry can need, checked before sizing from vertexCount.
            if (qsizetype(vertexCount - 1) * qsizetype(mesh->m_vertexBuffer.stride)
                        + 3 * qsizetype(sizeof(float))
                > qsizetype(vertexBufferDataSize)) {
                qWarning("Mesh morph target source does not fit a %u byte vertex buffer of stride "
                         "%u", vertexBufferDataSize, mesh->m_vertexBuffer.stride);
                return 0;
            }
            const quint32 targetEntryTexWidth = qCeil(qSqrt(vertexCount));
            qsizetype targetCompStride = 0;
            qsizetype targetBufferSize = 0;
            if (qMulOverflow(qsizetype(targetEntryTexWidth), qsizetype(targetEntryTexWidth),
                             &targetCompStride)
                || qMulOverflow(targetCompStride, qsizetype(4 * sizeof(float)), &targetCompStride)
                || qMulOverflow(targetCompStride, qsizetype(targetBufferEntriesCount),
                                &targetBufferSize)) {
                qWarning("Mesh morph target buffer for %u vertices is too large", vertexCount);
                return 0;
            }
            mesh->m_targetBuffer.data.resize(targetBufferSize);
            const quint32 numComps = targetBufferEntriesCount / numTargets;
            for (quint32 i = 0; i < targetBufferEntriesCount; ++i) {
                auto &entry = mesh->m_targetBuffer.entries[i];
                const qsizetype dstOffset = qsizetype(i / numComps) * targetCompStride
                        + qsizetype(i % numComps) * targetCompStride * numTargets;
                // Three floats per vertex, so it is the last twelve byte copy
                // that has to fit.
                const qsizetype copyBytes = 3 * qsizetype(sizeof(float));
                const qsizetype dstNeeded = dstOffset
                        + qsizetype(vertexCount - 1) * qsizetype(4 * sizeof(float)) + copyBytes;
                const qsizetype srcNeeded = qsizetype(entry.offset)
                        + qsizetype(vertexCount - 1) * qsizetype(mesh->m_vertexBuffer.stride)
                        + copyBytes;
                if (dstOffset < 0 || dstNeeded > targetBufferSize
                    || srcNeeded > mesh->m_vertexBuffer.data.size()) {
                    qWarning("Mesh morph target entry %u does not fit its buffer", i);
                    return 0;
                }
                char *dstBuf = mesh->m_targetBuffer.data.data() + dstOffset;
                const char *srcBuf = mesh->m_vertexBuffer.data.constData() + entry.offset;
                for (quint32 j = 0; j < vertexCount; ++j) {
                    memcpy(dstBuf + j * 4 * sizeof(float),
                           srcBuf + j * mesh->m_vertexBuffer.stride,
                           3 * sizeof(float));
                }
                entry.offset = i * targetCompStride;
            }
            // now we don't need to have redundant targetbuffer entries
            mesh->m_targetBuffer.entries.remove(numComps, targetBufferEntriesCount - numComps);
            mesh->m_targetBuffer.numTargets = numTargets;
        }
    }
 
    // These go straight to drawIndexed() or draw(), so a range outside the
    // buffer it indexes has to be caught here rather than by the driver.
    const quint32 indexSize = byteSizeForComponentType(mesh->m_indexBuffer.componentType);
    quint64 drawableCount = 0;
    if (!mesh->m_indexBuffer.data.isEmpty())
        drawableCount = indexSize ? quint64(mesh->m_indexBuffer.data.size()) / indexSize : 0;
    else if (mesh->m_vertexBuffer.stride)
        drawableCount = quint64(mesh->m_vertexBuffer.data.size()) / mesh->m_vertexBuffer.stride;
 
    for (const Mesh::Subset &subset : std::as_const(mesh->m_subsets)) {
        if (quint64(subset.offset) + subset.count > drawableCount) {
            qWarning("Mesh subset draws %u from %u, but only %llu are available", subset.count,
                     subset.offset, qulonglong(drawableCount));
            return 0;
        }
        for (const Mesh::Lod &lod : subset.lods) {
            if (quint64(lod.offset) + lod.count > drawableCount) {
                qWarning("Mesh level of detail draws %u from %u, but only %llu are available",
                         lod.count, lod.offset, qulonglong(drawableCount));
                return 0;
            }
        }
    }
 
    return header->sizeInBytes;
}
 
void MeshInternal::writeMeshHeader(QIODevice *device, const MeshDataHeader &header)
{
    QDataStream outputStream(device);
    outputStream.setByteOrder(QDataStream::LittleEndian);
    outputStream.setFloatingPointPrecision(QDataStream::SinglePrecision);
 
    outputStream << header.fileId << header.fileVersion << header.flags << header.sizeInBytes;
}
 
// The legacy, now-removed, insane mesh code used to use a "serialization"
// strategy with dumping memory, yet combined with with an in-memory layout
// that is different from what's in the file. In version 4 we no longer write
// out valid offset values (see the // legacy offset comments), because the new
// loader does not need them, and calculating them is not sensible, especially
// due to the different layouts. We still do the alignment padding, even though
// that's also legacy nonsense, but having that allows the reader not have to
// branch based on the version.
 
quint64 MeshInternal::writeMeshData(QIODevice *device, const Mesh &mesh)
{
    static const char alignPadding[4] = {};
 
    QDataStream outputStream(device);
    outputStream.setByteOrder(QDataStream::LittleEndian);
    outputStream.setFloatingPointPrecision(QDataStream::SinglePrecision);
 
    // The buffers bypass the stream, so one flag covers their writes and is
    // tested at the end with the stream's own status.
    bool writesOk = true;
    auto writeBytes = [&](const char *data, qint64 size) {
        if (size > 0 && device->write(data, size) != size)
            writesOk = false;
    };
 
    const qint64 startPos = device->pos();
    MeshInternal::MeshOffsetTracker offsetTracker(startPos);
    Q_ASSERT(offsetTracker.offset() == device->pos());
 
    const quint32 vertexBufferEntriesCount = mesh.m_vertexBuffer.entries.size();
    const quint32 vertexBufferDataSize = mesh.m_vertexBuffer.data.size();
    const quint32 vertexBufferStride = mesh.m_vertexBuffer.stride;
    const quint32 targetBufferEntriesCount = mesh.m_targetBuffer.entries.count();
    const quint32 targetBufferDataSize = mesh.m_targetBuffer.data.size();
    outputStream << targetBufferEntriesCount
                 << vertexBufferEntriesCount
                 << vertexBufferStride;
    outputStream << targetBufferDataSize
                 << vertexBufferDataSize;
 
    const quint32 indexBufferDataSize = mesh.m_indexBuffer.data.size();
    const quint32 indexComponentType = quint32(mesh.m_indexBuffer.componentType);
    outputStream << indexComponentType;
    outputStream << quint32(0) // legacy offset
                 << indexBufferDataSize;
 
    const quint32 targetCount = mesh.m_targetBuffer.numTargets;
    const quint32 subsetsCount = mesh.m_subsets.size();
    outputStream << targetCount
                 << subsetsCount;
 
    outputStream << quint32(0) // legacy offset
                 << quint32(0); // legacy jointsCount
 
    const quint32 drawMode = quint32(mesh.m_drawMode);
    const quint32 winding = quint32(mesh.m_winding);
    outputStream << drawMode
                 << winding;
 
    offsetTracker.advance(MESH_STRUCT_SIZE);
 
    quint32 entriesByteSize = 0;
    for (quint32 i = 0; i < vertexBufferEntriesCount; ++i) {
        const Mesh::VertexBufferEntry &entry(mesh.m_vertexBuffer.entries[i]);
        const quint32 componentType = quint32(entry.componentType);
        const quint32 componentCount = entry.componentCount;
        const quint32 offset = entry.offset;
        outputStream << quint32(0) // legacy offset
                     << componentType
                     << componentCount
                     << offset;
        entriesByteSize += VERTEX_BUFFER_ENTRY_STRUCT_SIZE;
    }
    quint32 alignAmount = offsetTracker.alignedAdvance(entriesByteSize);
    if (alignAmount)
        writeBytes(alignPadding, alignAmount);
 
    for (quint32 i = 0; i < vertexBufferEntriesCount; ++i) {
        const Mesh::VertexBufferEntry &entry(mesh.m_vertexBuffer.entries[i]);
        const quint32 nameLength = entry.name.size() + 1;
        outputStream << nameLength;
        writeBytes(entry.name.constData(), nameLength); // with zero terminator included
        alignAmount = offsetTracker.alignedAdvance(sizeof(quint32) + nameLength);
        if (alignAmount)
            writeBytes(alignPadding, alignAmount);
    }
 
    writeBytes(mesh.m_vertexBuffer.data.constData(), vertexBufferDataSize);
    alignAmount = offsetTracker.alignedAdvance(vertexBufferDataSize);
    if (alignAmount)
        writeBytes(alignPadding, alignAmount);
 
    writeBytes(mesh.m_indexBuffer.data.constData(), indexBufferDataSize);
    alignAmount = offsetTracker.alignedAdvance(indexBufferDataSize);
    if (alignAmount)
        writeBytes(alignPadding, alignAmount);
 
    quint32 subsetByteSize = 0;
    for (quint32 i = 0; i < subsetsCount; ++i) {
        const Mesh::Subset &subset(mesh.m_subsets[i]);
        const quint32 subsetCount = subset.count;
        const quint32 subsetOffset = subset.offset;
        const float minX = subset.bounds.min.x();
        const float minY = subset.bounds.min.y();
        const float minZ = subset.bounds.min.z();
        const float maxX = subset.bounds.max.x();
        const float maxY = subset.bounds.max.y();
        const float maxZ = subset.bounds.max.z();
        const quint32 nameLength = subset.name.size() + 1;
        const quint32 lightmapSizeHintWidth = qMax(0, subset.lightmapSizeHint.width());
        const quint32 lightmapSizeHintHeight = qMax(0, subset.lightmapSizeHint.height());
        const quint32 lodCount = subset.lods.size();
        outputStream << subsetCount
                     << subsetOffset
                     << minX
                     << minY
                     << minZ
                     << maxX
                     << maxY
                     << maxZ;
        outputStream << quint32(0) // legacy offset
                     << nameLength;
        outputStream << lightmapSizeHintWidth
                     << lightmapSizeHintHeight;
        outputStream << lodCount;
        subsetByteSize += SUBSET_STRUCT_SIZE_V6;
    }
    alignAmount = offsetTracker.alignedAdvance(subsetByteSize);
    if (alignAmount)
        writeBytes(alignPadding, alignAmount);
 
    for (quint32 i = 0; i < subsetsCount; ++i) {
        const Mesh::Subset &subset(mesh.m_subsets[i]);
        const char *utf16Name = reinterpret_cast<const char *>(subset.name.utf16());
        const quint32 nameByteSize = (subset.name.size() + 1) * 2;
        writeBytes(utf16Name, nameByteSize);
        alignAmount = offsetTracker.alignedAdvance(nameByteSize);
        if (alignAmount)
            writeBytes(alignPadding, alignAmount);
    }
 
    // LOD data
    quint32 lodDataByteSize = 0;
    for (quint32 i = 0; i < subsetsCount; ++i) {
        const Mesh::Subset &subset(mesh.m_subsets[i]);
        for (auto lod : subset.lods) {
            const quint32 count = lod.count;
            const quint32 offset = lod.offset;
            const float distance = lod.distance;
            outputStream << count << offset << distance;
            lodDataByteSize += LOD_STRUCT_SIZE;
        }
    }
    alignAmount = offsetTracker.alignedAdvance(lodDataByteSize);
    if (alignAmount)
        writeBytes(alignPadding, alignAmount);
 
    // Data for morphTargets
    for (quint32 i = 0; i < targetBufferEntriesCount; ++i) {
        const Mesh::VertexBufferEntry &entry(mesh.m_targetBuffer.entries[i]);
        const quint32 componentType = quint32(entry.componentType);
        const quint32 componentCount = entry.componentCount;
        const quint32 offset = entry.offset;
        outputStream << quint32(0) // legacy offset
                     << componentType
                     << componentCount
                     << offset;
        entriesByteSize += VERTEX_BUFFER_ENTRY_STRUCT_SIZE;
    }
    alignAmount = offsetTracker.alignedAdvance(entriesByteSize);
    if (alignAmount)
        writeBytes(alignPadding, alignAmount);
 
    for (quint32 i = 0; i < targetBufferEntriesCount; ++i) {
        const Mesh::VertexBufferEntry &entry(mesh.m_targetBuffer.entries[i]);
        const quint32 nameLength = entry.name.size() + 1;
        outputStream << nameLength;
        writeBytes(entry.name.constData(), nameLength); // with zero terminator included
        alignAmount = offsetTracker.alignedAdvance(sizeof(quint32) + nameLength);
        if (alignAmount)
            writeBytes(alignPadding, alignAmount);
    }
 
    writeBytes(mesh.m_targetBuffer.data.constData(), targetBufferDataSize);
 
    if (!writesOk || outputStream.status() != QDataStream::Ok) {
        qWarning("Failed to write mesh data");
        return 0;
    }
 
    const quint32 endPos = device->pos();
    const quint32 sizeInBytes = endPos - startPos;
    device->seek(endPos);
    return sizeInBytes;
}
 
Mesh Mesh::loadMesh(QIODevice *device, quint32 id)
{
    MeshInternal::MeshDataHeader header;
    const MeshInternal::MultiMeshInfo meshFileInfo = MeshInternal::readFileHeader(device);
    auto it = meshFileInfo.meshEntries.constFind(id);
    if (it != meshFileInfo.meshEntries.constEnd()) {
        Mesh mesh;
        quint64 size = MeshInternal::readMeshData(device, *it, &mesh, &header);
        if (size)
            return mesh;
    } else if (id == 0 && !meshFileInfo.meshEntries.isEmpty()) {
        Mesh mesh;
        quint64 size = MeshInternal::readMeshData(device, *meshFileInfo.meshEntries.cbegin(), &mesh, &header);
        if (size)
            return mesh;
    }
    return Mesh();
}
 
QMap<quint32, Mesh> Mesh::loadAll(QIODevice *device)
{
    MeshInternal::MeshDataHeader header;
    const MeshInternal::MultiMeshInfo meshFileInfo = MeshInternal::readFileHeader(device);
    QMap<quint32, Mesh> meshes;
    for (auto it = meshFileInfo.meshEntries.cbegin(), end = meshFileInfo.meshEntries.cend(); it != end; ++it) {
        Mesh mesh;
        quint64 size = MeshInternal::readMeshData(device, *it, &mesh, &header);
        if (size)
            meshes.insert(it.key(), mesh);
        else
            qWarning("Failed to find mesh #%u", it.key());
    }
    return meshes;
}
 
static inline quint32 getAlignedOffset(quint32 offset, quint32 align)
{
    Q_ASSERT(align > 0);
    const quint32 leftover = (align > 0) ? offset % align : 0;
    if (leftover)
        return offset + (align - leftover);
    return offset;
}
 
Mesh Mesh::fromAssetData(const QVector<AssetVertexEntry> &vbufEntries,
                         const QByteArray &indexBufferData,
                         ComponentType indexComponentType,
                         const QVector<AssetMeshSubset> &subsets,
                         quint32 numTargets,
                         quint32 numTargetComps)
{
    Mesh mesh;
    quint32 currentOffset = 0;
    quint32 bufferAlignment = 0;
    quint32 numItems = 0;
    bool ok = true;
 
    mesh.m_targetBuffer.numTargets = numTargets;
    quint32 targetCurrentComp = 0;
    quint32 targetCompStride = 0;
 
    QVector<AssetVertexEntry> vEntries;
    for (const AssetVertexEntry &entry : vbufEntries) {
        // Ignore entries with no data.
        if (entry.data.isEmpty())
            continue;
 
        VertexBufferEntry meshEntry;
        meshEntry.componentType = entry.componentType;
        meshEntry.componentCount = entry.componentCount;
        meshEntry.name = entry.name;
 
        if (entry.morphTargetId < 0) {
            const quint32 alignment = MeshInternal::byteSizeForComponentType(entry.componentType);
            const quint32 byteSize = alignment * entry.componentCount;
 
            if (entry.data.size() % alignment != 0) {
                Q_ASSERT(false);
                ok = false;
            }
 
            quint32 localNumItems = entry.data.size() / byteSize;
            if (numItems == 0) {
                numItems = localNumItems;
            } else if (numItems != localNumItems) {
                Q_ASSERT(false);
                ok = false;
                numItems = qMin(numItems, localNumItems);
            }
 
            currentOffset = getAlignedOffset(currentOffset, alignment);
            meshEntry.offset = currentOffset;
 
            mesh.m_vertexBuffer.entries.append(meshEntry);
            currentOffset += byteSize;
            bufferAlignment = qMax(bufferAlignment, alignment);
            vEntries.append(entry);
        } else {
            if (!targetCompStride) {
                const quint32 targetEntrySize = entry.data.size();
                quint32 targetEntryTexWidth = qCeil(qSqrt(((targetEntrySize + 15) >> 4)));
                targetCompStride = targetEntryTexWidth * targetEntryTexWidth * 4 * sizeof(float);
                mesh.m_targetBuffer.data.resize(targetCompStride * numTargets * numTargetComps);
            }
 
            // At assets, these entries are appended sequentially from target 0 to target N - 1
            // It is safe to calculate the offset by the data size
            meshEntry.offset = (targetCurrentComp * numTargets + entry.morphTargetId)
                                    * targetCompStride;
            memcpy(mesh.m_targetBuffer.data.data() + meshEntry.offset,
                   entry.data.constData(), entry.data.size());
 
            // Note: the targetBuffer will not be interleaved,
            // data will be just appended in order and used for a texture array.
            if (entry.morphTargetId == 0)
                mesh.m_targetBuffer.entries.append(meshEntry);
 
            targetCurrentComp = (targetCurrentComp + 1 < numTargetComps) ? targetCurrentComp + 1 : 0;
        }
    }
 
    if (!ok)
        return Mesh();
 
    mesh.m_vertexBuffer.stride = getAlignedOffset(currentOffset, bufferAlignment);
 
    // Packed interleave the data.
    for (quint32 idx = 0; idx < numItems; ++idx) {
        quint32 dataOffset = 0;
        for (const AssetVertexEntry &entry : vEntries) {
            if (entry.data.isEmpty())
                continue;
 
            const quint32 alignment = MeshInternal::byteSizeForComponentType(entry.componentType);
            const quint32 byteSize = alignment * entry.componentCount;
            const quint32 offset = byteSize * idx;
            const quint32 newOffset = getAlignedOffset(dataOffset, alignment);
            if (newOffset != dataOffset) {
                QByteArray filler(newOffset - dataOffset, '\0');
                mesh.m_vertexBuffer.data.append(filler);
            }
 
            mesh.m_vertexBuffer.data.append(entry.data.constData() + offset, byteSize);
            dataOffset = newOffset + byteSize;
        }
        Q_ASSERT(dataOffset == mesh.m_vertexBuffer.stride);
    }
 
    mesh.m_indexBuffer.componentType = indexComponentType;
    mesh.m_indexBuffer.data = indexBufferData;
 
    for (const AssetMeshSubset &subset : subsets) {
        Mesh::Subset meshSubset;
        meshSubset.name = subset.name;
        meshSubset.count = subset.count;
        meshSubset.offset = subset.offset;
 
        // TODO: QTBUG-102026
        if (subset.boundsPositionEntryIndex != std::numeric_limits<quint32>::max()) {
            const QSSGBounds3 bounds = MeshInternal::calculateSubsetBounds(
                    mesh.m_vertexBuffer.entries[subset.boundsPositionEntryIndex],
                    mesh.m_vertexBuffer.data,
                    mesh.m_vertexBuffer.stride,
                    mesh.m_indexBuffer.data,
                    mesh.m_indexBuffer.componentType,
                    subset.count,
                    subset.offset);
            meshSubset.bounds.min = bounds.minimum;
            meshSubset.bounds.max = bounds.maximum;
        }
 
        meshSubset.lightmapSizeHint = QSize(subset.lightmapWidth, subset.lightmapHeight);
        meshSubset.lods = subset.lods;
 
        mesh.m_subsets.append(meshSubset);
    }
 
    mesh.m_drawMode = DrawMode::Triangles;
    mesh.m_winding = Winding::CounterClockwise;
 
    return mesh;
}
 
Mesh Mesh::fromRuntimeData(const RuntimeMeshData &data, QString *error)
{
    if (data.m_vertexBuffer.size() == 0) {
        *error = QObject::tr("Vertex buffer empty");
        return Mesh();
    }
    if (data.m_attributeCount == 0) {
        *error = QObject::tr("No attributes defined");
        return Mesh();
    }
 
    Mesh mesh;
    mesh.m_drawMode = data.m_primitiveType;
    mesh.m_winding = Winding::CounterClockwise;
 
    for (int i = 0; i < data.m_attributeCount; ++i) {
        const RuntimeMeshData::Attribute &att = data.m_attributes[i];
        if (att.semantic == RuntimeMeshData::Attribute::IndexSemantic) {
            mesh.m_indexBuffer.componentType = att.componentType;
        } else {
            const char *name = nullptr;
            switch (att.semantic) {
            case RuntimeMeshData::Attribute::PositionSemantic:
                name = MeshInternal::getPositionAttrName();
                break;
            case RuntimeMeshData::Attribute::NormalSemantic:
                name = MeshInternal::getNormalAttrName();
                break;
            case RuntimeMeshData::Attribute::TexCoord0Semantic:
                name = MeshInternal::getUV0AttrName();
                break;
            case RuntimeMeshData::Attribute::TexCoord1Semantic:
                name = MeshInternal::getUV1AttrName();
                break;
            case RuntimeMeshData::Attribute::TangentSemantic:
                name = MeshInternal::getTexTanAttrName();
                break;
            case RuntimeMeshData::Attribute::BinormalSemantic:
                name = MeshInternal::getTexBinormalAttrName();
                break;
            case RuntimeMeshData::Attribute::JointSemantic:
                name = MeshInternal::getJointAttrName();
                break;
            case RuntimeMeshData::Attribute::WeightSemantic:
                name = MeshInternal::getWeightAttrName();
                break;
            case RuntimeMeshData::Attribute::ColorSemantic:
                name = MeshInternal::getColorAttrName();
                break;
            default:
                *error = QObject::tr("Warning: Invalid attribute semantic: %1")
                        .arg(att.semantic);
                return Mesh();
            }
 
            VertexBufferEntry entry;
            entry.componentType = att.componentType;
            entry.componentCount = att.componentCount();
            entry.offset = att.offset;
            entry.name = name;
            mesh.m_vertexBuffer.entries.append(entry);
        }
    }
 
    mesh.m_vertexBuffer.data = data.m_vertexBuffer;
    // Only interleaved vertex attribute packing is supported, both internally
    // and in the QQuick3DGeometry API, hence the per-vertex buffer stride.
    mesh.m_vertexBuffer.stride = data.m_stride;
    mesh.m_subsets = data.m_subsets;
    mesh.m_indexBuffer.data = data.m_indexBuffer;
 
    if (!data.m_targetBuffer.isEmpty()) {
        const quint32 vertexCount = data.m_vertexBuffer.size() / data.m_stride;
        const quint32 targetEntryTexWidth = qCeil(qSqrt(vertexCount));
        const quint32 targetCompStride = targetEntryTexWidth * targetEntryTexWidth * 4 * sizeof(float);
        mesh.m_targetBuffer.data.resize(targetCompStride * data.m_targetAttributeCount);
 
        QVarLengthArray<RuntimeMeshData::TargetAttribute> sortedAttribs(
                                            data.m_targetAttributes,
                                            data.m_targetAttributes + data.m_targetAttributeCount);
        std::sort(sortedAttribs.begin(), sortedAttribs.end(),
                  [] (RuntimeMeshData::TargetAttribute a, RuntimeMeshData::TargetAttribute b) {
                  return (a.targetId == b.targetId) ? a.attr.semantic < b.attr.semantic :
                                                      a.targetId < b.targetId; });
        for (int i = 0; i < data.m_targetAttributeCount; ++i) {
            const RuntimeMeshData::Attribute &att = sortedAttribs[i].attr;
            const int stride = (sortedAttribs[i].stride < 1) ? att.componentCount() * sizeof(float)
                                                             : sortedAttribs[i].stride;
            const char *name = nullptr;
            switch (att.semantic) {
            case RuntimeMeshData::Attribute::PositionSemantic:
                name = MeshInternal::getPositionAttrName();
                break;
            case RuntimeMeshData::Attribute::NormalSemantic:
                name = MeshInternal::getNormalAttrName();
                break;
            case RuntimeMeshData::Attribute::TexCoord0Semantic:
                name = MeshInternal::getUV0AttrName();
                break;
            case RuntimeMeshData::Attribute::TexCoord1Semantic:
                name = MeshInternal::getUV1AttrName();
                break;
            case RuntimeMeshData::Attribute::TangentSemantic:
                name = MeshInternal::getTexTanAttrName();
                break;
            case RuntimeMeshData::Attribute::BinormalSemantic:
                name = MeshInternal::getTexBinormalAttrName();
                break;
            case RuntimeMeshData::Attribute::IndexSemantic:
            case RuntimeMeshData::Attribute::JointSemantic:
            case RuntimeMeshData::Attribute::WeightSemantic:
                *error = QObject::tr("Warning: Invalid target attribute semantic: %1")
                        .arg(att.semantic);
                continue;
            case RuntimeMeshData::Attribute::ColorSemantic:
                name = MeshInternal::getColorAttrName();
                break;
            default:
                *error = QObject::tr("Warning: Invalid target attribute semantic: %1")
                        .arg(att.semantic);
                return Mesh();
            }
            char *dstBuf = mesh.m_targetBuffer.data.data() + i * targetCompStride;
            const char *srcBuf = data.m_targetBuffer.constData() + att.offset;
            Q_ASSERT(att.componentType == Mesh::ComponentType::Float32);
            if (stride == 4 * sizeof(float)) {
                memcpy(dstBuf, srcBuf, vertexCount * stride);
            } else {
                for (quint32 j = 0; j < vertexCount; ++j) {
                    memcpy(dstBuf + j * 4 * sizeof(float),
                           srcBuf + j * stride,
                           att.componentCount() * sizeof(float));
                }
            }
 
            if (sortedAttribs[i].targetId == 0) {
                VertexBufferEntry entry;
                entry.componentType = att.componentType;
                entry.componentCount = att.componentCount();
                entry.offset = i * targetCompStride;
                entry.name = name;
                mesh.m_targetBuffer.entries.append(entry);
            }
        }
        mesh.m_targetBuffer.numTargets = data.m_targetAttributeCount / mesh.m_targetBuffer.entries.size();
    }
    return mesh;
}
 
quint32 Mesh::save(QIODevice *device, quint32 id) const
{
    qint64 newMeshStartPosFromEnd = 0;
    quint32 newId = 1;
    MeshInternal::MultiMeshInfo header;
 
    if (device->size() > 0) {
        header = MeshInternal::readFileHeader(device);
        if (!header.isValid()) {
            qWarning("There is existing data, but mesh file header is invalid; cannot save");
            return 0;
        }
        for (auto it = header.meshEntries.cbegin(), end = header.meshEntries.cend(); it != end; ++it) {
            if (id) {
                Q_ASSERT(id != it.key());
                newId = id;
            } else {
                newId = qMax(newId, it.key() + 1);
            }
        }
        newMeshStartPosFromEnd = MULTI_HEADER_STRUCT_SIZE + header.meshEntries.size() * MULTI_ENTRY_STRUCT_SIZE;
    } else {
        header = MeshInternal::MultiMeshInfo::withDefaults();
    }
 
    // the new mesh data overwrites the entry list and file header
    device->seek(device->size() - newMeshStartPosFromEnd);
    const qint64 meshOffset = device->pos();
    header.meshEntries.insert(newId, meshOffset);
 
    MeshInternal::MeshDataHeader meshHeader = MeshInternal::MeshDataHeader::withDefaults();
    // skip the space for the mesh header for now
    device->seek(device->pos() + MESH_HEADER_STRUCT_SIZE);
    meshHeader.sizeInBytes = MeshInternal::writeMeshData(device, *this);
    if (meshHeader.sizeInBytes == 0)
        return 0;
    // now the mesh header is ready to be written out
    device->seek(meshOffset);
    MeshInternal::writeMeshHeader(device, meshHeader);
    device->seek(meshOffset + MESH_HEADER_STRUCT_SIZE + meshHeader.sizeInBytes);
    // write out new entry list and file header
    MeshInternal::writeFileHeader(device, header);
 
    return newId;
}
 
QSSGBounds3 MeshInternal::calculateSubsetBounds(const Mesh::VertexBufferEntry &entry,
                                                const QByteArray &vertexBufferData,
                                                quint32 vertexBufferStride,
                                                const QByteArray &indexBufferData,
                                                Mesh::ComponentType indexComponentType,
                                                quint32 subsetCount,
                                                quint32 subsetOffset)
{
    QSSGBounds3 result;
    if (entry.componentType != Mesh::ComponentType::Float32 || entry.componentCount != 3) {
        Q_ASSERT(false);
        return result;
    }
 
    const int indexComponentByteSize = byteSizeForComponentType(indexComponentType);
    if (indexComponentByteSize != 2 && indexComponentByteSize != 4) {
        Q_ASSERT(false);
        return result;
    }
 
    const quint32 indexBufferCount = indexBufferData.size() / indexComponentByteSize;
    const quint32 vertexBufferByteSize = vertexBufferData.size();
    const char *vertexSrcPtr = vertexBufferData.constData();
    const char *indexSrcPtr = indexBufferData.constData();
 
    for (quint32 idx = 0, numItems = subsetCount; idx < numItems; ++idx) {
        if (idx + subsetOffset >= indexBufferCount)
            continue;
 
        quint32 vertexIdx = 0;
        switch (indexComponentByteSize) {
        case 2:
            vertexIdx = reinterpret_cast<const quint16 *>(indexSrcPtr)[idx + subsetOffset];
            break;
        case 4:
            vertexIdx = reinterpret_cast<const quint32 *>(indexSrcPtr)[idx + subsetOffset];
            break;
        default:
            Q_UNREACHABLE();
            break;
        }
 
        const quint32 finalOffset = entry.offset + (vertexIdx * vertexBufferStride);
        float v[3];
        if (finalOffset + sizeof(v) <= vertexBufferByteSize) {
            memcpy(v, vertexSrcPtr + finalOffset, sizeof(v));
            result.include(QVector3D(v[0], v[1], v[2]));
        } else {
            Q_ASSERT(false);
        }
    }
 
    return result;
}
 
bool Mesh::hasLightmapUVChannel() const
{
    const char *lightmapAttrName = MeshInternal::getLightmapUVAttrName();
    for (const VertexBufferEntry &vbe : std::as_const(m_vertexBuffer.entries)) {
        if (vbe.name == lightmapAttrName)
            return true;
    }
    return false;
}
 
bool Mesh::createLightmapUVChannel(float texelsPerUnit, const QMatrix4x4 &scale)
{
    const char *posAttrName = MeshInternal::getPositionAttrName();
    const char *normalAttrName = MeshInternal::getNormalAttrName();
    const char *uvAttrName = MeshInternal::getUV0AttrName();
    const char *lightmapAttrName = MeshInternal::getLightmapUVAttrName();
 
    // this function should do nothing if there is already an attr_lightmapuv
    if (hasLightmapUVChannel())
        return true;
 
    const char *srcVertexData = m_vertexBuffer.data.constData();
    const quint32 srcVertexStride = m_vertexBuffer.stride;
    if (!srcVertexStride) {
        qWarning("Lightmap UV unwrapping encountered a Mesh with 0 vertex stride, this cannot happen");
        return false;
    }
    if (m_indexBuffer.data.isEmpty()) {
        qWarning("Lightmap UV unwrapping encountered a Mesh without index data, this cannot happen");
        return false;
    }
 
    quint32 positionOffset = UINT32_MAX;
    quint32 normalOffset = UINT32_MAX;
    quint32 uvOffset = UINT32_MAX;
 
    for (const VertexBufferEntry &vbe : std::as_const(m_vertexBuffer.entries)) {
        if (vbe.name == posAttrName) {
            if (vbe.componentCount != 3) {
                qWarning("Lightmap UV unwrapping encountered a Mesh non-float3 position data, this cannot happen");
                return false;
            }
            positionOffset = vbe.offset;
        } else if (vbe.name == normalAttrName) {
            if (vbe.componentCount != 3) {
                qWarning("Lightmap UV unwrapping encountered a Mesh non-float3 normal data, this cannot happen");
                return false;
            }
            normalOffset = vbe.offset;
        } else if (vbe.name == uvAttrName) {
            if (vbe.componentCount != 2) {
                qWarning("Lightmap UV unwrapping encountered a Mesh non-float2 UV0 data, this cannot happen");
                return false;
            }
            uvOffset = vbe.offset;
        }
    }
 
    if (positionOffset == UINT32_MAX) {
        qWarning("Lightmap UV unwrapping encountered a Mesh without vertex positions, this cannot happen");
        return false;
    }
    // normal and uv0 are optional
 
    const qsizetype vertexCount = m_vertexBuffer.data.size() / srcVertexStride;
    QByteArray positionData(vertexCount * 3 * sizeof(float), Qt::Uninitialized);
    float *posPtr = reinterpret_cast<float *>(positionData.data());
    for (qsizetype i = 0; i < vertexCount; ++i) {
        const char *vertexBasePtr = srcVertexData + i * srcVertexStride;
        const float *srcPos = reinterpret_cast<const float *>(vertexBasePtr + positionOffset);
        QVector3D srcV;
        srcV.setX(*srcPos++);
        srcV.setY(*srcPos++);
        srcV.setZ(*srcPos++);
        // We scale the positions here, but not on the source mesh, so that the uv unwrapper works on
        // the positions that the model will have in the scene after its scaling has been applied. This
        // way the texels-per-unit will be correct.
        srcV = scale.map(srcV);
        *posPtr++ = srcV.x();
        *posPtr++ = srcV.y();
        *posPtr++ = srcV.z();
    }
 
    QByteArray normalData;
    if (normalOffset != UINT32_MAX) {
        normalData.resize(vertexCount * 3 * sizeof(float));
        float *normPtr = reinterpret_cast<float *>(normalData.data());
        for (qsizetype i = 0; i < vertexCount; ++i) {
            const char *vertexBasePtr = srcVertexData + i * srcVertexStride;
            const float *srcNormal = reinterpret_cast<const float *>(vertexBasePtr + normalOffset);
            *normPtr++ = *srcNormal++;
            *normPtr++ = *srcNormal++;
            *normPtr++ = *srcNormal++;
        }
    }
 
    QByteArray uvData;
    if (uvOffset != UINT32_MAX) {
        uvData.resize(vertexCount * 2 * sizeof(float));
        float *uvPtr = reinterpret_cast<float *>(uvData.data());
        for (qsizetype i = 0; i < vertexCount; ++i) {
            const char *vertexBasePtr = srcVertexData + i * srcVertexStride;
            const float *srcUv = reinterpret_cast<const float *>(vertexBasePtr + uvOffset);
            *uvPtr++ = *srcUv++;
            *uvPtr++ = *srcUv++;
        }
    }
 
    QSSGLightmapUVGenerator uvGen;
    QSSGLightmapUVGeneratorResult r = uvGen.run(positionData, normalData, uvData,
                                                m_indexBuffer.data, m_indexBuffer.componentType,
                                                texelsPerUnit);
    if (!r.isValid())
        return false;
 
    // the result can have more (but never less) vertices than the input
    const int newVertexCount = r.vertexMap.size();
 
    // r.indexData contains the new index data that has the same number of elements as before
    const quint32 *newIndex = reinterpret_cast<const quint32 *>(r.indexData.constData());
    if (m_indexBuffer.componentType == QSSGMesh::Mesh::ComponentType::UnsignedInt32) {
        if (r.indexData.size() != m_indexBuffer.data.size()) {
            qWarning("Index buffer size mismatch after lightmap UV unwrapping");
            return false;
        }
        quint32 *indexDst = reinterpret_cast<quint32 *>(m_indexBuffer.data.data());
        memcpy(indexDst, newIndex, m_indexBuffer.data.size());
    } else {
        if (r.indexData.size() != m_indexBuffer.data.size() * 2) {
            qWarning("Index buffer size mismatch after lightmap UV unwrapping");
            return false;
        }
        quint16 *indexDst = reinterpret_cast<quint16 *>(m_indexBuffer.data.data());
        for (size_t i = 0, count = m_indexBuffer.data.size() / sizeof(quint16); i != count; ++i)
            *indexDst++ = *newIndex++;
    }
 
    QVarLengthArray<QByteArray, 8> newData;
    newData.reserve(m_vertexBuffer.entries.size());
 
    for (const VertexBufferEntry &vbe : std::as_const(m_vertexBuffer.entries)) {
        const qsizetype byteSize = vbe.componentCount * MeshInternal::byteSizeForComponentType(vbe.componentType);
        QByteArray data(byteSize * vertexCount, Qt::Uninitialized);
        char *dst = data.data();
        for (qsizetype i = 0; i < vertexCount; ++i) {
            memcpy(dst, srcVertexData + i * srcVertexStride + vbe.offset, byteSize);
            dst += byteSize;
        }
        switch (vbe.componentType) {
        case ComponentType::UnsignedInt8:
            newData.append(QSSGLightmapUVGenerator::remap<quint8>(data, r.vertexMap, vbe.componentCount));
            break;
        case ComponentType::Int8:
            newData.append(QSSGLightmapUVGenerator::remap<qint8>(data, r.vertexMap, vbe.componentCount));
            break;
        case ComponentType::UnsignedInt16:
            newData.append(QSSGLightmapUVGenerator::remap<quint16>(data, r.vertexMap, vbe.componentCount));
            break;
        case ComponentType::Int16:
            newData.append(QSSGLightmapUVGenerator::remap<qint16>(data, r.vertexMap, vbe.componentCount));
            break;
        case ComponentType::UnsignedInt32:
            newData.append(QSSGLightmapUVGenerator::remap<quint32>(data, r.vertexMap, vbe.componentCount));
            break;
        case ComponentType::Int32:
            newData.append(QSSGLightmapUVGenerator::remap<qint32>(data, r.vertexMap, vbe.componentCount));
            break;
        case ComponentType::UnsignedInt64:
            newData.append(QSSGLightmapUVGenerator::remap<quint64>(data, r.vertexMap, vbe.componentCount));
            break;
        case ComponentType::Int64:
            newData.append(QSSGLightmapUVGenerator::remap<qint64>(data, r.vertexMap, vbe.componentCount));
            break;
        case ComponentType::Float16:
            newData.append(QSSGLightmapUVGenerator::remap<qfloat16>(data, r.vertexMap, vbe.componentCount));
            break;
        case ComponentType::Float32:
            newData.append(QSSGLightmapUVGenerator::remap<float>(data, r.vertexMap, vbe.componentCount));
            break;
        case ComponentType::Float64:
            newData.append(QSSGLightmapUVGenerator::remap<double>(data, r.vertexMap, vbe.componentCount));
            break;
        }
    }
 
    VertexBufferEntry lightmapUVEntry;
    lightmapUVEntry.componentType = ComponentType::Float32;
    lightmapUVEntry.componentCount = 2;
    lightmapUVEntry.offset = 0;
    lightmapUVEntry.name = lightmapAttrName;
 
    QByteArray newVertexBuffer;
    newVertexBuffer.reserve(newVertexCount * (srcVertexStride + 8));
 
    quint32 bufferAlignment = 0;
    for (int vertexIdx = 0; vertexIdx < newVertexCount; ++vertexIdx) {
        quint32 dataOffset = 0;
        for (int vbIdx = 0, end = m_vertexBuffer.entries.size(); vbIdx != end; ++vbIdx) {
            VertexBufferEntry &vbe(m_vertexBuffer.entries[vbIdx]);
 
            const quint32 alignment = MeshInternal::byteSizeForComponentType(vbe.componentType);
            bufferAlignment = qMax(bufferAlignment, alignment);
            const quint32 byteSize = alignment * vbe.componentCount;
            const quint32 newOffset = getAlignedOffset(dataOffset, alignment);
 
            if (newOffset != dataOffset) {
                QByteArray filler(newOffset - dataOffset, '\0');
                newVertexBuffer.append(filler);
            }
 
            if (vertexIdx == 0)
                vbe.offset = newVertexBuffer.size();
 
            newVertexBuffer.append(newData[vbIdx].constData() + byteSize * vertexIdx, byteSize);
            dataOffset = newOffset + byteSize;
        }
 
        const quint32 byteSize = 2 * sizeof(float);
        const quint32 newOffset = getAlignedOffset(dataOffset, byteSize);
        if (newOffset != dataOffset) {
            QByteArray filler(newOffset - dataOffset, '\0');
            newVertexBuffer.append(filler);
        }
 
        if (vertexIdx == 0)
            lightmapUVEntry.offset = newVertexBuffer.size();
 
        newVertexBuffer.append(r.lightmapUVChannel.constData() + byteSize * vertexIdx, byteSize);
        dataOffset = newOffset + byteSize;
 
        if (vertexIdx == 0)
            m_vertexBuffer.stride = getAlignedOffset(dataOffset, bufferAlignment);
    }
 
    m_vertexBuffer.entries.append(lightmapUVEntry);
 
    m_vertexBuffer.data = newVertexBuffer;
 
    const QSize lightmapSizeHint(r.lightmapWidth, r.lightmapHeight);
    for (Subset &subset : m_subsets)
        subset.lightmapSizeHint = lightmapSizeHint;
 
    return true;
}
 
size_t simplifyMesh(unsigned int *destination, const unsigned int *indices, size_t indexCount, const float *vertexPositions, size_t vertexCount, size_t vertexPositionsStride, size_t targetIndexCount, float targetError, unsigned int options, float *resultError)
{
    return meshopt_simplify(destination, indices, indexCount, vertexPositions, vertexCount, vertexPositionsStride, targetIndexCount, targetError, options, resultError);
}
 
float simplifyScale(const float *vertexPositions, size_t vertexCount, size_t vertexPositionsStride)
{
    return meshopt_simplifyScale(vertexPositions, vertexCount, vertexPositionsStride);
}
 
void optimizeVertexCache(unsigned int *destination, const unsigned int *indices, size_t indexCount, size_t vertexCount)
{
    meshopt_optimizeVertexCache(destination, indices, indexCount, vertexCount);
}
 
size_t generateVertexRemap(unsigned int *destination,
                           const unsigned int *indices,
                           size_t indexCount,
                           size_t vertexCount,
                           const MeshVertexStream *streams,
                           size_t streamCount)
{
    Q_ASSERT(streamCount > 0 && streamCount <= maxVertexStreams);
    QVarLengthArray<meshopt_Stream, 16> meshoptStreams;
    for (size_t i = 0; i < streamCount; ++i)
        meshoptStreams.append({ streams[i].data, streams[i].elementSize, streams[i].stride });
    return meshopt_generateVertexRemapMulti(destination, indices, indexCount, vertexCount,
                                            meshoptStreams.constData(), streamCount);
}
 
void generateTangents(float *destination,
                      const unsigned int *indices,
                      size_t indexCount,
                      const float *vertexPositions,
                      size_t vertexCount,
                      size_t vertexPositionsStride,
                      const float *vertexNormals,
                      size_t vertexNormalsStride,
                      const float *vertexUvs,
                      size_t vertexUvsStride)
{
    meshopt_generateTangents(destination, indices, indexCount,
                             vertexPositions, vertexCount, vertexPositionsStride,
                             vertexNormals, vertexNormalsStride,
                             vertexUvs, vertexUvsStride, 0);
}
 
void remapVertexBuffer(void *destination,
                       const void *vertices,
                       size_t vertexCount,
                       size_t vertexSize,
                       const unsigned int *remap)
{
    meshopt_remapVertexBuffer(destination, vertices, vertexCount, vertexSize, remap);
}
 
void remapIndexBuffer(unsigned int *destination,
                      const unsigned int *indices,
                      size_t indexCount,
                      const unsigned int *remap)
{
    meshopt_remapIndexBuffer(destination, indices, indexCount, remap);
}
 
QVector<MeshLevelOfDetail> generateMeshLevelsOfDetail(const QVector<QVector3D> &positions,
                                                      const QVector<QVector3D> &normals,
                                                      const QVector<quint32> &indexes,
                                                      QVector<MeshVertexSplit> &splitVertices,
                                                      float normalMergeAngle,
                                                      float normalSplitAngle)
{
    // The split vertices are reported positionally, starting at
    // positions.size(), so stale entries would make the caller's append loop
    // line up with the wrong vertices
    splitVertices.clear();
 
    if (positions.isEmpty() || indexes.isEmpty())
        return {};
 
    // Correcting normals needs one per position. Both angles being 0.0 also
    // means the caller does not want them recalculated at all.
    const bool recalculateNormals = normals.size() == positions.size()
            && !(qFuzzyIsNull(normalMergeAngle) && qFuzzyIsNull(normalSplitAngle));
    const float normalMergeThreshold = qCos(qDegreesToRadians(normalMergeAngle));
    const float normalSplitThreshold = qCos(qDegreesToRadians(normalSplitAngle));
 
    quint32 splitVertexCount = positions.size();
 
    // An edge can only be collapsed when its vertices are shared by the faces
    // around it, so a vertex that appears more than once in the vertex buffer
    // pins every edge that touches it. Assets are very commonly authored with
    // one vertex per triangle corner - faceted normals and UV chart borders
    // both force a split, and some exporters simply never weld - and such a
    // mesh has no collapsible edge anywhere, so simplification returns the
    // input unchanged and not a single level is produced. Weld by position to
    // recover the real topology, simplify that, and translate the result back
    // to the caller's vertex numbering afterwards, so the vertex buffer they
    // hold is still the one the returned indexes refer to.
    //
    // Only the normals are rewritten below, so a position split to carry
    // different normals can be welded, but one split to carry a different
    // normal that has to be *kept* cannot: every face around it would be left
    // reading whichever of them the weld happened to pick. So when the caller
    // asked for the stored normals to be preserved, they join the weld key and
    // a hard edge stays pinned, at the cost of fewer levels for such a mesh.
    QVector<quint32> weldRemap(positions.size());
    QVarLengthArray<MeshVertexStream, 2> streams;
    streams.append({ positions.constData(), sizeof(QVector3D), sizeof(QVector3D) });
    if (!recalculateNormals && normals.size() == positions.size())
        streams.append({ normals.constData(), sizeof(QVector3D), sizeof(QVector3D) });
    const quint32 weldedVertexCount = quint32(generateVertexRemap(weldRemap.data(), indexes.constData(),
                                                          indexes.size(),
                                                          positions.size(), streams.constData(),
                                                          size_t(streams.size())));
    QVector<quint32> weldedIndexes(indexes.size());
    remapIndexBuffer(weldedIndexes.data(), indexes.constData(), indexes.size(), weldRemap.constData());
    QVector<QVector3D> weldedPositions(weldedVertexCount);
    remapVertexBuffer(weldedPositions.data(), positions.constData(), positions.size(), sizeof(QVector3D),
                      weldRemap.constData());
 
    // Pick one original vertex to stand for each welded one, so the simplified
    // indexes can be mapped back. Every vertex welded together agrees on the
    // attributes the weld key covers, so the choice only matters for the rest:
    // where a position was split across a UV chart border the LOD has to settle
    // on one of the charts either way.
    constexpr quint32 unusedVertex = std::numeric_limits<quint32>::max();
    QVector<quint32> weldedToOriginal(weldedVertexCount, unusedVertex);
    for (quint32 i = 0, end = quint32(positions.size()); i < end; ++i) {
        const quint32 welded = weldRemap.at(i);
        // Vertices the index buffer never references are left unmapped
        if (welded != unusedVertex && weldedToOriginal.at(welded) == unusedVertex)
            weldedToOriginal[welded] = i;
    }
 
    const float targetError = std::numeric_limits<float>::max(); // error doesn't matter, index count is more important
    const float *vertexData = reinterpret_cast<const float *>(weldedPositions.constData());
    const float scaleFactor = simplifyScale(vertexData, weldedVertexCount, sizeof(QVector3D));
    const quint32 indexCount = indexes.size();
    // A level is kept when it is at least half again the previous one and still
    // under three quarters of the mesh; simplifyMesh() rounds up to whole
    // triangles, so a larger target only yields levels that get thrown away.
    const quint32 maxLevelIndexes = indexCount - indexCount / 4 - 1;
    const quint32 maxIndexTarget = maxLevelIndexes - maxLevelIndexes % 3;
    quint32 indexTarget = 12;
    quint32 lastIndexCount = 0;
    QVector<MeshLevelOfDetail> lods;
 
    while (indexTarget < indexCount) {
        float error;
        QVector<quint32> newIndexes;
        newIndexes.resize(indexCount); // Must be the same size as the original indexes to pass to simplifyMesh
        size_t newLength = simplifyMesh(newIndexes.data(), weldedIndexes.constData(), weldedIndexes.size(),
                                        vertexData, weldedVertexCount, sizeof(QVector3D), indexTarget,
                                        targetError, 0, &error);
 
        // Not good enough, try again
        if (newLength < lastIndexCount + (lastIndexCount + 1) / 2) {
            const quint32 nextTarget = qMin(indexTarget + indexTarget / 2, maxIndexTarget);
            if (nextTarget <= indexTarget)
                break;
            indexTarget = nextTarget;
            continue;
        }
 
        // We are done
        if (newLength == 0 || newLength > maxLevelIndexes)
            break;
 
        newIndexes.resize(newLength);
 
        // Back to the caller's vertex numbering, which everything below - and
        // the returned levels - is expressed in
        for (quint32 &index : newIndexes)
            index = weldedToOriginal.at(index);
 
        // LOD Normal Correction
        if (recalculateNormals) {
            // Cull any new degenerate triangles and get the new face normals
            QVector<QVector3D> faceNormals;
            {
                QVector<quint32> culledIndexes;
                for (quint32 j = 0; j < quint32(newIndexes.size()); j += 3) {
                    const QVector3D &v0 = positions[newIndexes[j]];
                    const QVector3D &v1 = positions[newIndexes[j + 1]];
                    const QVector3D &v2 = positions[newIndexes[j + 2]];
 
                    QVector3D faceNormal = QVector3D::crossProduct(v1 - v0, v2 - v0);
                    // This normalizes the vector in place and returns the magnitude
                    const float faceArea = QSSGUtils::vec3::normalize(faceNormal);
                    // It is possible that the simplifyMesh process gave us a degenerate triangle
                    // (all three at the same point, or on the same line) or such a small triangle
                    // that a float value doesn't have enough resolution. In that case cull the
                    // "face" since it would not get rendered in a meaningful way anyway
                    if (faceArea != 0.0f) {
                        faceNormals.append(faceNormal);
                        faceNormals.append(faceNormal);
                        faceNormals.append(faceNormal);
                        culledIndexes.append({newIndexes[j], newIndexes[j + 1], newIndexes[j + 2]});
                    }
                }
 
                if (newIndexes.size() != culledIndexes.size())
                    newIndexes = culledIndexes;
            }
 
            // Group all shared vertices together by position. We need to know adjacent faces
            // to do vertex normal remapping in the next step.
            const quint32 newIndexCount = quint32(newIndexes.size());
            QHash<QVector3D, QVector<quint32>> positionHash;
            for (quint32 i = 0; i < newIndexCount; ++i) {
                const quint32 index = newIndexes[i];
                const QVector3D position = positions[index];
                positionHash[position].append(i);
            }
 
            // Go through each vertex and calculate the normals by checking each
            // adjacent face that share the same vertex position, and create a smoothed
            // normal if the angle between thew face normals is less than the the
            // normalMergeAngle passed to this function (>= since this is cos(radian(angle)) )
            QVector<QPair<quint32, quint32>> remapIndexes;
            for (quint32 positionIndex = 0; positionIndex < newIndexCount; ++positionIndex) {
                const quint32 index = newIndexes[positionIndex];
                const QVector3D &position = positions[index];
                const QVector3D &faceNormal = faceNormals[positionIndex];
                QVector3D newNormal;
                // Find all vertices that share the same position
                const auto &sharedPositions = positionHash.value(position);
                for (const auto positionIndex2 : sharedPositions) {
                    if (positionIndex == positionIndex2) {
                        // Don't test against the current face under test
                        newNormal += faceNormal;
                    } else {
                        const QVector3D &faceNormal2 = faceNormals[positionIndex2];
                        if (QVector3D::dotProduct(faceNormal2, faceNormal) >= normalMergeThreshold)
                            newNormal += faceNormal2;
                    }
                }
 
                // By normalizing here we get an averaged value of all smoothed normals
                QSSGUtils::vec3::normalize(newNormal);
 
                // Now that we know what the smoothed normal would be, check how differnt
                // that normal is from the normal that is already stored in the current
                // index. If the angle delta is greater than normalSplitAngle then we need
                // to create a new vertex entry (making a copy of the current one) and set
                // the new normal value, and reassign the current index to point to that new
                // vertex. Generally the LOD simplification process is such that the existing
                // normal will already be ideal until we start getting to the very low lod levels
                // which changes the topology in such a way that the original normal doesn't
                // make sense anymore, thus the need to provide a more reasonable value.
                const QVector3D &originalNormal = normals[index];
                const float theta = QVector3D::dotProduct(originalNormal, newNormal);
                if (theta < normalSplitThreshold) {
                    splitVertices.append({ index, newNormal.normalized() });
                    remapIndexes.append({positionIndex, splitVertexCount++});
                }
            }
 
            // Do index remap now that all new normals have been calculated
            for (const auto &pair : std::as_const(remapIndexes))
                newIndexes[pair.first] = pair.second;
        }
 
        lods.append({error * scaleFactor, newIndexes});
        lastIndexCount = quint32(newLength);
 
        // No level can be both big enough and small enough any more
        if (lastIndexCount + (lastIndexCount + 1) / 2 > maxLevelIndexes)
            break;
 
        const size_t doubled = qMax(newLength, size_t(indexTarget)) * 2; // may exceed quint32
        const quint32 nextTarget = quint32(qMin<size_t>(doubled, maxIndexTarget));
        if (nextTarget <= indexTarget)
            break;
        indexTarget = nextTarget;
 
        if (error == 0.0f)
            break;
    }
 
    return lods;
}
 
} // namespace QSSGMesh
 
QT_END_NAMESPACE