qt/qtquick3d/src/utils/qssgmesh.cpp

Revision control

++ // 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