qssggltfparser.cpp

++ // Copyright (C) 2026 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

++ // Qt-Security score:critical reason:data-parser

++

++ #include "qssggltfparser_p.h"

++ #include "qssggltfresourceresolver_p.h"

++

++ #include <QtCore/qendian.h>

++ #include <QtCore/qfile.h>

++ #include <QtCore/qfileinfo.h>

++ #include <QtCore/qhash.h>

++ #include <QtCore/qjsonarray.h>

++ #include <QtCore/qjsondocument.h>

++ #include <QtCore/qset.h>

++ #include <QtCore/qvarlengtharray.h>

++

++ #include "meshoptimizer.h"

++

++ QT_BEGIN_NAMESPACE

++

++ Q_LOGGING_CATEGORY(lcQuick3DGltf, "qt.quick3d.gltf")

++

++ using namespace QSSGGltf;

++

++ namespace {

++

++ // GLB container constants

++ constexpr quint32 GLB_MAGIC = 0x46546C67; // 'glTF'

++ constexpr quint32 GLB_CHUNK_JSON = 0x4E4F534A; // 'JSON'

++ constexpr quint32 GLB_CHUNK_BIN = 0x004E4942; // 'BIN\0'

++

++ QVector3D toVector3D(const QJsonArray &array, const QVector3D &defaultValue = {})

++ {

++     if (array.size() < 3)

++         return defaultValue;

++     return QVector3D(float(array.at(0).toDouble()), float(array.at(1).toDouble()), float(array.at(2).toDouble()));

++ }

++

++ QVector4D toVector4D(const QJsonArray &array, const QVector4D &defaultValue = {})

++ {

++     if (array.size() < 4)

++         return defaultValue;

++     return QVector4D(float(array.at(0).toDouble()), float(array.at(1).toDouble()),

++                      float(array.at(2).toDouble()), float(array.at(3).toDouble()));

++ }

++

++ TextureInfo parseTextureInfo(const QJsonObject &object, const char *scaleOrStrengthKey = nullptr)

++ {

++     TextureInfo info;

++     if (object.isEmpty())

++         return info;

++     info.index = object.value(QLatin1String("index")).toInt(-1);

++     info.texCoord = object.value(QLatin1String("texCoord")).toInt(0);

++     if (scaleOrStrengthKey)

++         info.scaleOrStrength = float(object.value(QLatin1String(scaleOrStrengthKey)).toDouble(1.0));

++

++     const QJsonObject extensions = object.value(QLatin1String("extensions")).toObject();

++     const QJsonValue transformValue = extensions.value(QLatin1String("KHR_texture_transform"));

++     if (transformValue.isObject()) {

++         const QJsonObject t = transformValue.toObject();

++         TextureTransform transform;

++         const QJsonArray offset = t.value(QLatin1String("offset")).toArray();

++         if (offset.size() >= 2)

++             transform.offset = QVector2D(float(offset.at(0).toDouble()), float(offset.at(1).toDouble()));

++         const QJsonArray scale = t.value(QLatin1String("scale")).toArray();

++         if (scale.size() >= 2)

++             transform.scale = QVector2D(float(scale.at(0).toDouble(1.0)), float(scale.at(1).toDouble(1.0)));

++         transform.rotation = float(t.value(QLatin1String("rotation")).toDouble(0.0));

++         transform.texCoord = t.value(QLatin1String("texCoord")).toInt(-1);

++         info.transform = transform;

++     }

++     return info;

++ }

++

++ Accessor::Type accessorTypeFromString(const QString &type, bool *ok)

++ {

++     *ok = true;

++     if (type == QLatin1String("SCALAR"))

++         return Accessor::Type::Scalar;

++     if (type == QLatin1String("VEC2"))

++         return Accessor::Type::Vec2;

++     if (type == QLatin1String("VEC3"))

++         return Accessor::Type::Vec3;

++     if (type == QLatin1String("VEC4"))

++         return Accessor::Type::Vec4;

++     if (type == QLatin1String("MAT2"))

++         return Accessor::Type::Mat2;

++     if (type == QLatin1String("MAT3"))

++         return Accessor::Type::Mat3;

++     if (type == QLatin1String("MAT4"))

++         return Accessor::Type::Mat4;

++     *ok = false;

++     return Accessor::Type::Scalar;

++ }

++

++ bool isValidComponentType(int value)

++ {

++     switch (Accessor::ComponentType(value)) {

++     case Accessor::ComponentType::Byte:

++     case Accessor::ComponentType::UnsignedByte:

++     case Accessor::ComponentType::Short:

++     case Accessor::ComponentType::UnsignedShort:

++     case Accessor::ComponentType::UnsignedInt:

++     case Accessor::ComponentType::Float:

++         return true;

++     }

++     return false;

++ }

++

++ // Views can alias the same compressed bytes, so the budget is per document

++ struct MeshoptDecodeState

++ {

++     qint64 remainingBytes = qint64(1024) * 1024 * 1024;

++     QHash<QString, int> decodedBuffers; // decode parameters -> synthetic buffer index

++ };

++

++ // Returns -1 for anything but a non-negative integer below 2^53

++ qint64 toByteCount(const QJsonValue &value, double defaultValue)

++ {

++     const double d = value.toDouble(defaultValue);

++     return d >= 0.0 && d <= 9007199254740992.0 ? qint64(d) : -1;

++ }

++

++ // Decodes into a synthetic buffer and points the view at it

++ bool decodeMeshoptBufferView(const QJsonObject &ext, QSSGGltfDocument &document, BufferView &view,

++                              MeshoptDecodeState &state, QString *errorMessage)

++ {

++     const auto fail = [errorMessage](const QString &message) {

++         *errorMessage = message;

++         return false;

++     };

++

++     const int sourceBuffer = ext.value(QLatin1String("buffer")).toInt(-1);

++     const qint64 byteOffset = toByteCount(ext.value(QLatin1String("byteOffset")), 0.0);

++     const qint64 byteLength = toByteCount(ext.value(QLatin1String("byteLength")), -1.0);

++     const qint64 byteStride = toByteCount(ext.value(QLatin1String("byteStride")), -1.0);

++

++     // Checked as double, since the qint64 product can wrap

++     constexpr qint64 maxDecodedBytes = qint64(1024) * 1024 * 1024;

++     const double rawCount = ext.value(QLatin1String("count")).toDouble();

++     if (!(byteStride > 0 && rawCount > 0.0 && rawCount * double(byteStride) <= double(maxDecodedBytes)))

++         return fail(QStringLiteral("unreasonable decoded data size"));

++     const qint64 count = qint64(rawCount);

++

++     const QString mode = ext.value(QLatin1String("mode")).toString();

++     const QString filter = ext.value(QLatin1String("filter")).toString(QStringLiteral("NONE"));

++

++     if (sourceBuffer < 0 || sourceBuffer >= document.buffers.size()

++         || document.buffers.at(sourceBuffer).meshoptFallback) {

++         return fail(QStringLiteral("compressed data references invalid buffer %1").arg(sourceBuffer));

++     }

++     const Buffer &compressed = document.buffers.at(sourceBuffer);

++     // Not summed, since offset + length can wrap

++     if (byteOffset < 0 || byteLength <= 0 || byteLength > compressed.byteLength

++         || byteOffset > compressed.byteLength - byteLength) {

++         return fail(QStringLiteral("compressed data is outside buffer %1").arg(sourceBuffer));

++     }

++

++     enum class Mode { Attributes, Triangles, Indices };

++     Mode decodeMode;

++     if (mode == QLatin1String("ATTRIBUTES"))

++         decodeMode = Mode::Attributes;

++     else if (mode == QLatin1String("TRIANGLES"))

++         decodeMode = Mode::Triangles;

++     else if (mode == QLatin1String("INDICES"))

++         decodeMode = Mode::Indices;

++     else

++         return fail(QStringLiteral("unsupported compression mode '%1'").arg(mode));

++

++     // Stride limits required by the decoders

++     if (decodeMode == Mode::Attributes) {

++         if (byteStride < 4 || byteStride > 256 || byteStride % 4)

++             return fail(QStringLiteral("invalid byte stride %1 for ATTRIBUTES mode").arg(byteStride));

++     } else {

++         if (byteStride != 2 && byteStride != 4)

++             return fail(QStringLiteral("invalid byte stride %1 for index data").arg(byteStride));

++         if (decodeMode == Mode::Triangles && count % 3)

++             return fail(QStringLiteral("TRIANGLES element count %1 is not divisible by 3").arg(count));

++         if (filter != QLatin1String("NONE"))

++             return fail(QStringLiteral("filters do not apply to index data"));

++     }

++

++     if (decodeMode == Mode::Attributes && filter != QLatin1String("NONE") && filter != QLatin1String("OCTAHEDRAL")

++         && filter != QLatin1String("QUATERNION") && filter != QLatin1String("EXPONENTIAL")) {

++         return fail(QStringLiteral("unsupported filter '%1'").arg(filter));

++     }

++     if ((filter == QLatin1String("OCTAHEDRAL") && byteStride != 4 && byteStride != 8)

++         || (filter == QLatin1String("QUATERNION") && byteStride != 8)) {

++         return fail(QStringLiteral("invalid byte stride %1 for filter %2").arg(byteStride).arg(filter));

++     }

++

++     const QString key = QStringLiteral("%1:%2:%3:%4:%5:%6:%7")

++                                 .arg(sourceBuffer).arg(byteOffset).arg(byteLength).arg(count)

++                                 .arg(byteStride).arg(mode, filter);

++     const auto rewriteView = [&view, decodeMode, byteStride](int buffer, qint64 length) {

++         view.buffer = buffer;

++         view.byteOffset = 0;

++         view.byteLength = length;

++         view.byteStride = decodeMode == Mode::Attributes ? int(byteStride) : 0;

++     };

++     if (const auto it = state.decodedBuffers.constFind(key); it != state.decodedBuffers.constEnd()) {

++         rewriteView(*it, document.buffers.at(*it).byteLength);

++         return true;

++     }

++     if (count * byteStride > state.remainingBytes)

++         return fail(QStringLiteral("decoded data exceeds the limit for the document"));

++

++     QByteArray decoded(count * byteStride, Qt::Uninitialized);

++     const auto *source = reinterpret_cast<const unsigned char *>(compressed.data.constData()) + byteOffset;

++     int result = -1;

++     switch (decodeMode) {

++     case Mode::Attributes:

++         result = meshopt_decodeVertexBuffer(decoded.data(), size_t(count), size_t(byteStride), source,

++                                             size_t(byteLength));

++         break;

++     case Mode::Triangles:

++         result = meshopt_decodeIndexBuffer(decoded.data(), size_t(count), size_t(byteStride), source,

++                                            size_t(byteLength));

++         break;

++     case Mode::Indices:

++         result = meshopt_decodeIndexSequence(decoded.data(), size_t(count), size_t(byteStride), source,

++                                              size_t(byteLength));

++         break;

++     }

++     if (result != 0)

++         return fail(QStringLiteral("corrupt compressed data"));

++

++     if (filter == QLatin1String("OCTAHEDRAL"))

++         meshopt_decodeFilterOct(decoded.data(), size_t(count), size_t(byteStride));

++     else if (filter == QLatin1String("QUATERNION"))

++         meshopt_decodeFilterQuat(decoded.data(), size_t(count), size_t(byteStride));

++     else if (filter == QLatin1String("EXPONENTIAL"))

++         meshopt_decodeFilterExp(decoded.data(), size_t(count), size_t(byteStride));

++

++     state.remainingBytes -= decoded.size();

++     Buffer decodedBuffer;

++     decodedBuffer.byteLength = decoded.size();

++     decodedBuffer.data = std::move(decoded);

++     document.buffers.append(decodedBuffer);

++     const int bufferIndex = int(document.buffers.size() - 1);

++     state.decodedBuffers.insert(key, bufferIndex);

++     rewriteView(bufferIndex, decodedBuffer.byteLength);

++     return true;

++ }

++

++ } // namespace

++

++ /*!

++     \class QSSGGltfParser

++     \internal

++

++     Parses glTF 2.0 content (.gltf JSON or binary .glb container) into a

++     QSSGGltfDocument. Buffers (external files, data: URIs, and the GLB BIN

++     chunk) are resolved eagerly; image contents are left unresolved.

++

++     Validation is two-tier: structural violations (out-of-range indices,

++     accessors extending past their buffer view, truncated GLB, unsupported

++     required extensions) fail the parse with an error message; tolerable

++     deviations from the specification are logged as warnings and clamped,

++     repaired, or ignored, matching the leniency of other glTF consumers. A

++     node with more than one parent and a scene root that is not unique both

++     fall in the second group: the offending edge is dropped, because the node

++     hierarchy has to be a forest for consumers to recurse over it safely, but

++     the rest of the asset is still worth loading.

++ */

++

++ /*!

++     \internal

++

++     Returns the extensions the parser understands. Assets that list anything

++     else in extensionsRequired fail to parse.

++

++     Being on this list means the extension is represented in QSSGGltfDocument,

++     not that any particular consumer acts on it: a consumer that ignores one

++     of these still gets a document it can load.

++ */

++ QStringList QSSGGltfParser::supportedExtensions()

++ {

++     // Order does not matter; keep alphabetical for readability. Extensions

++     // needing a decoder we do not ship (KHR_draco_mesh_compression,

++     // KHR_texture_basisu) are intentionally absent and get a clear error

++     // when required by an asset.

++     // KHR_xmp_json_ld is accepted, but left in the raw extension objects.

++     return {

++         QStringLiteral("EXT_mesh_gpu_instancing"),

++         QStringLiteral("EXT_meshopt_compression"),

++         QStringLiteral("EXT_texture_webp"),

++         QStringLiteral("KHR_lights_punctual"),

++         QStringLiteral("KHR_materials_anisotropy"),

++         QStringLiteral("KHR_materials_clearcoat"),

++         QStringLiteral("KHR_materials_dispersion"),

++         QStringLiteral("KHR_materials_emissive_strength"),

++         QStringLiteral("KHR_materials_ior"),

++         QStringLiteral("KHR_materials_iridescence"),

++         QStringLiteral("KHR_materials_pbrSpecularGlossiness"),

++         QStringLiteral("KHR_materials_sheen"),

++         QStringLiteral("KHR_materials_specular"),

++         QStringLiteral("KHR_materials_transmission"),

++         QStringLiteral("KHR_materials_unlit"),

++         QStringLiteral("KHR_materials_variants"),

++         QStringLiteral("KHR_materials_volume"),

++         QStringLiteral("KHR_mesh_quantization"),

++         QStringLiteral("KHR_node_visibility"),

++         QStringLiteral("KHR_texture_transform"),

++         QStringLiteral("KHR_xmp_json_ld"),

++     };

++ }

++

++ bool QSSGGltfParser::setError(const QString &message)

++ {

++     m_errorMessage = message;

++     qCWarning(lcQuick3DGltf) << message;

++     return false;

++ }

++

++ /*!

++     \internal

++

++     Convenience overload of parse() reading \a filePath, a local file or qrc

++     path, into \a document.

++ */

++ bool QSSGGltfParser::parseFile(const QString &filePath, QSSGGltfDocument *document)

++ {

++     QFile file(filePath);

++     if (!file.open(QIODevice::ReadOnly))

++         return setError(QStringLiteral("Failed to open '%1': %2").arg(filePath, file.errorString()));

++     return parse(file.readAll(), QFileInfo(filePath).path(), document);

++ }

++

++ /*!

++     \internal

++

++     Parses .gltf JSON or a .glb container in \a data into \a document.

++     \a baseDir is the local or qrc directory used to resolve relative

++     buffer and image URIs.

++ */

++ bool QSSGGltfParser::parse(const QByteArray &data, const QString &baseDir, QSSGGltfDocument *document)

++ {

++     Q_ASSERT(document);

++     m_errorMessage.clear();

++     *document = QSSGGltfDocument();

++     document->baseDir = baseDir;

++

++     QByteArray json = data;

++     QByteArray binChunk;

++

++     // Binary container? (12-byte header: magic, version, length)

++     if (data.size() >= 12 && qFromLittleEndian<quint32>(data.constData()) == GLB_MAGIC) {

++         const quint32 version = qFromLittleEndian<quint32>(data.constData() + 4);

++         if (version != 2)

++             return setError(QStringLiteral("Unsupported GLB container version %1").arg(version));

++         const quint32 length = qFromLittleEndian<quint32>(data.constData() + 8);

++         if (qint64(length) > data.size())

++             return setError(QStringLiteral("Truncated GLB file: header declares %1 bytes, got %2")

++                             .arg(length).arg(data.size()));

++

++         json.clear();

++         qint64 offset = 12;

++         while (offset + 8 <= qint64(length)) {

++             QT_WARNING_PUSH QT_WARNING_DISABLE_GCC("-Warray-bounds")

++             // gcc 15.2.0 warns because of static const char _empty in QByteArray

++             const quint32 chunkLength = qFromLittleEndian<quint32>(data.constData() + offset);

++             const quint32 chunkType = qFromLittleEndian<quint32>(data.constData() + offset + 4);

++             QT_WARNING_POP

++             offset += 8;

++             if (offset + qint64(chunkLength) > qint64(length))

++                 return setError(QStringLiteral("Truncated GLB chunk at offset %1").arg(offset - 8));

++

++             if (chunkType == GLB_CHUNK_JSON && json.isEmpty())

++                 json = data.mid(offset, chunkLength);

++             else if (chunkType == GLB_CHUNK_BIN && binChunk.isEmpty())

++                 binChunk = data.mid(offset, chunkLength);

++             else

++                 qCWarning(lcQuick3DGltf) << "Skipping unknown GLB chunk type" << Qt::hex << chunkType;

++

++             // Chunks are 4-byte aligned

++             offset += chunkLength;

++             if (offset % 4)

++                 offset += 4 - (offset % 4);

++         }

++         if (json.isEmpty())

++             return setError(QStringLiteral("GLB container has no JSON chunk"));

++     }

++

++     QJsonParseError jsonError;

++     const QJsonDocument jsonDocument = QJsonDocument::fromJson(json, &jsonError);

++     if (jsonDocument.isNull())

++         return setError(QStringLiteral("Invalid glTF JSON: %1").arg(jsonError.errorString()));

++     if (!jsonDocument.isObject())

++         return setError(QStringLiteral("Invalid glTF JSON: root is not an object"));

++

++     const QJsonObject root = jsonDocument.object();

++

++     // asset (required)

++     {

++         const QJsonValue assetValue = root.value(QLatin1String("asset"));

++         if (!assetValue.isObject())

++             return setError(QStringLiteral("Not a glTF document: no asset object"));

++         const QJsonObject asset = assetValue.toObject();

++         document->asset.version = asset.value(QLatin1String("version")).toString();

++         document->asset.minVersion = asset.value(QLatin1String("minVersion")).toString();

++         document->asset.generator = asset.value(QLatin1String("generator")).toString();

++         document->asset.copyright = asset.value(QLatin1String("copyright")).toString();

++

++         const int major = document->asset.version.section(QLatin1Char('.'), 0, 0).toInt();

++         if (major != 2)

++             return setError(QStringLiteral("Unsupported glTF version '%1'").arg(document->asset.version));

++

++         // The specification requires a client to fail when minVersion asks for

++         // more than it implements. Only 2.0 exists so far, so this is about not

++         // silently loading a future asset that says it needs more.

++         if (!document->asset.minVersion.isEmpty()) {

++             const int minMajor = document->asset.minVersion.section(QLatin1Char('.'), 0, 0).toInt();

++             const int minMinor = document->asset.minVersion.section(QLatin1Char('.'), 1, 1).toInt();

++             if (minMajor != 2 || minMinor > 0)

++                 return setError(QStringLiteral("Asset requires glTF version '%1' or higher")

++                                         .arg(document->asset.minVersion));

++         }

++     }

++

++     // extensionsUsed / extensionsRequired

++     const QJsonArray extensionsUsed = root.value(QLatin1String("extensionsUsed")).toArray();

++     for (const auto &value : extensionsUsed)

++         document->extensionsUsed.append(value.toString());

++     const QJsonArray extensionsRequired = root.value(QLatin1String("extensionsRequired")).toArray();

++     for (const auto &value : extensionsRequired)

++         document->extensionsRequired.append(value.toString());

++     document->rootExtensions = root.value(QLatin1String("extensions")).toObject();

++

++     // KHR_materials_variants (document level): the variant names

++     {

++         const QJsonValue variantsExt = document->rootExtensions.value(QLatin1String("KHR_materials_variants"));

++         if (variantsExt.isObject()) {

++             const QJsonArray variants = variantsExt.toObject().value(QLatin1String("variants")).toArray();

++             for (const auto &value : variants)

++                 document->materialVariants.append(value.toObject().value(QLatin1String("name")).toString());

++         }

++     }

++

++     const QStringList supported = supportedExtensions();

++     for (const QString &required : std::as_const(document->extensionsRequired)) {

++         if (!supported.contains(required))

++             return setError(QStringLiteral("Asset requires unsupported glTF extension '%1'").arg(required));

++     }

++     for (const QString &used : std::as_const(document->extensionsUsed)) {

++         if (!supported.contains(used))

++             qCWarning(lcQuick3DGltf) << "Ignoring unsupported glTF extension" << used;

++     }

++

++     // buffers

++     const QJsonArray buffers = root.value(QLatin1String("buffers")).toArray();

++     for (const auto &value : buffers) {

++         const QJsonObject object = value.toObject();

++         Buffer buffer;

++         buffer.uri = object.value(QLatin1String("uri")).toString();

++         buffer.byteLength = qint64(object.value(QLatin1String("byteLength")).toDouble());

++         if (buffer.byteLength < 0)

++             return setError(QStringLiteral("Buffer %1 has negative byte length").arg(document->buffers.size()));

++         buffer.meshoptFallback = object.value(QLatin1String("extensions")).toObject()

++                                          .value(QLatin1String("EXT_meshopt_compression")).toObject()

++                                          .value(QLatin1String("fallback")).toBool(false);

++         if (buffer.meshoptFallback) {

++             document->buffers.append(buffer);

++             continue;

++         }

++         if (buffer.uri.isEmpty()) {

++             // GLB BIN chunk; only valid for the first buffer

++             if (document->buffers.isEmpty() && !binChunk.isEmpty())

++                 buffer.data = binChunk;

++             else if (binChunk.isEmpty())

++                 return setError(

++                         QStringLiteral("Buffer %1 has no URI and there is no GLB BIN chunk")

++                                 .arg(document->buffers.size()));

++             else

++                 return setError(QStringLiteral("Only the first buffer may refer to the GLB BIN chunk"));

++         } else {

++             QString resolveError;

++             buffer.data = QSSGGltfResourceResolver::loadUri(buffer.uri, baseDir, &resolveError);

++             // Loading can legitimately produce nothing, for an empty file or an

++             // empty data URI payload, so the error string is what says whether

++             // it failed. The length check below rejects a short buffer anyway.

++             if (!resolveError.isEmpty())

++                 return setError(QStringLiteral("Failed to load buffer %1: %2")

++                                 .arg(document->buffers.size()).arg(resolveError));

++         }

++         if (buffer.data.size() < buffer.byteLength)

++             return setError(QStringLiteral("Buffer %1 is %2 bytes, expected at least %3")

++                                     .arg(document->buffers.size()).arg(buffer.data.size()).arg(buffer.byteLength));

++         document->buffers.append(buffer);

++     }

++

++     // bufferViews

++     MeshoptDecodeState meshoptState;

++     const QJsonArray bufferViews = root.value(QLatin1String("bufferViews")).toArray();

++     for (const auto &value : bufferViews) {

++         const QJsonObject object = value.toObject();

++         BufferView view;

++         view.buffer = object.value(QLatin1String("buffer")).toInt(-1);

++         view.byteOffset = qint64(object.value(QLatin1String("byteOffset")).toDouble(0));

++         view.byteLength = qint64(object.value(QLatin1String("byteLength")).toDouble());

++         view.byteStride = object.value(QLatin1String("byteStride")).toInt(0);

++         view.target = object.value(QLatin1String("target")).toInt(0);

++         view.name = object.value(QLatin1String("name")).toString();

++

++         const QJsonValue meshoptValue = object.value(QLatin1String("extensions")).toObject()

++                                                 .value(QLatin1String("EXT_meshopt_compression"));

++         if (meshoptValue.isObject()) {

++             QString decodeError;

++             if (!decodeMeshoptBufferView(meshoptValue.toObject(), *document, view, meshoptState, &decodeError)) {

++                 return setError(QStringLiteral("Buffer view %1: EXT_meshopt_compression: %2")

++                                         .arg(document->bufferViews.size()).arg(decodeError));

++             }

++             document->bufferViews.append(view);

++             continue;

++         }

++

++         if (view.buffer < 0 || view.buffer >= document->buffers.size())

++             return setError(

++                     QStringLiteral("Buffer view %1 references invalid buffer %2")

++                             .arg(document->bufferViews.size()).arg(view.buffer));

++         if (document->buffers.at(view.buffer).meshoptFallback)

++             return setError(QStringLiteral("Buffer view %1 references unloaded fallback buffer %2")

++                                     .arg(document->bufferViews.size()).arg(view.buffer));

++         // The stride bound is from the specification; together with

++         // non-negative offsets and lengths it also keeps all later offset

++         // arithmetic far away from overflowing 64 bits.

++         if (view.byteOffset < 0 || view.byteLength < 0 || view.byteStride < 0 || view.byteStride > 252)

++             return setError(QStringLiteral("Buffer view %1 has an invalid byte offset, length, or stride")

++                                     .arg(document->bufferViews.size()));

++         // Compared without adding the two together: both are individually

++         // positive by the check above, but their sum can overflow to a negative

++         // value and slip under the buffer length.

++         const qint64 bufferLength = document->buffers.at(view.buffer).byteLength;

++         if (view.byteLength > bufferLength || view.byteOffset > bufferLength - view.byteLength)

++             return setError(

++                     QStringLiteral("Buffer view %1 extends past the end of buffer %2")

++                             .arg(document->bufferViews.size()).arg(view.buffer));

++         document->bufferViews.append(view);

++     }

++

++     // accessors

++     const QJsonArray accessors = root.value(QLatin1String("accessors")).toArray();

++     for (const auto &value : accessors) {

++         const QJsonObject object = value.toObject();

++         Accessor accessor;

++         accessor.bufferView = object.value(QLatin1String("bufferView")).toInt(-1);

++         accessor.byteOffset = qint64(object.value(QLatin1String("byteOffset")).toDouble(0));

++         const int componentType = object.value(QLatin1String("componentType")).toInt();

++         if (!isValidComponentType(componentType))

++             return setError(QStringLiteral("Accessor %1 has invalid component type %2")

++                             .arg(document->accessors.size()).arg(componentType));

++         accessor.componentType = Accessor::ComponentType(componentType);

++         bool typeOk = false;

++         accessor.type = accessorTypeFromString(object.value(QLatin1String("type")).toString(), &typeOk);

++         if (!typeOk)

++             return setError(QStringLiteral("Accessor %1 has invalid type '%2'")

++                                     .arg(document->accessors.size())

++                                     .arg(object.value(QLatin1String("type")).toString()));

++         // The specification puts no upper bound on count, but the offset

++         // arithmetic below needs one. A count near the top of the qint64 range

++         // makes those products overflow, which is undefined behavior, and in

++         // practice wraps the range test at the end of this loop into an

++         // acceptance: a ten-line document then yields an accessor claiming

++         // more elements than could ever be allocated. One element occupies at

++         // least one byte, so no real asset comes anywhere near this cap, and

++         // capping in elements keeps every product here well inside 64 bits.

++         constexpr qint64 maxAccessorElements = qint64(256) * 1024 * 1024;

++         const double rawCount = object.value(QLatin1String("count")).toDouble();

++         if (!(rawCount >= 0.0 && rawCount <= double(maxAccessorElements)))

++             return setError(QStringLiteral("Accessor %1 has a negative or unreasonably large count")

++                                     .arg(document->accessors.size()));

++         accessor.count = qint64(rawCount);

++         if (accessor.byteOffset < 0)

++             return setError(QStringLiteral("Accessor %1 has a negative byte offset")

++                                     .arg(document->accessors.size()));

++         accessor.normalized = object.value(QLatin1String("normalized")).toBool(false);

++         accessor.name = object.value(QLatin1String("name")).toString();

++         const QJsonArray minValues = object.value(QLatin1String("min")).toArray();

++         for (const auto &m : minValues)

++             accessor.min.append(m.toDouble());

++         const QJsonArray maxValues = object.value(QLatin1String("max")).toArray();

++         for (const auto &m : maxValues)

++             accessor.max.append(m.toDouble());

++

++         const QJsonValue sparseValue = object.value(QLatin1String("sparse"));

++         if (sparseValue.isObject()) {

++             const QJsonObject sparseObject = sparseValue.toObject();

++             Accessor::Sparse sparse;

++             // Bounded the same way as accessor.count, and for the same reason:

++             // it is multiplied by a component size a few lines down

++             const double rawSparseCount = sparseObject.value(QLatin1String("count")).toDouble();

++             if (!(rawSparseCount >= 0.0 && rawSparseCount <= double(maxAccessorElements)))

++                 return setError(QStringLiteral("Accessor %1 has a negative or unreasonably large sparse count")

++                                         .arg(document->accessors.size()));

++             sparse.count = qint64(rawSparseCount);

++             const QJsonObject indices = sparseObject.value(QLatin1String("indices")).toObject();

++             sparse.indicesBufferView = indices.value(QLatin1String("bufferView")).toInt(-1);

++             sparse.indicesByteOffset = qint64(indices.value(QLatin1String("byteOffset")).toDouble(0));

++             const int indicesComponentType = indices.value(QLatin1String("componentType")).toInt();

++             if (!isValidComponentType(indicesComponentType))

++                 return setError(

++                         QStringLiteral("Accessor %1 sparse indices have invalid component type")

++                                 .arg(document->accessors.size()));

++             sparse.indicesComponentType = Accessor::ComponentType(indicesComponentType);

++             const QJsonObject values = sparseObject.value(QLatin1String("values")).toObject();

++             sparse.valuesBufferView = values.value(QLatin1String("bufferView")).toInt(-1);

++             sparse.valuesByteOffset = qint64(values.value(QLatin1String("byteOffset")).toDouble(0));

++

++             if (sparse.indicesBufferView < 0 || sparse.indicesBufferView >= document->bufferViews.size()

++                 || sparse.valuesBufferView < 0 || sparse.valuesBufferView >= document->bufferViews.size()) {

++                 return setError(QStringLiteral("Accessor %1 sparse data references an invalid buffer view")

++                                         .arg(document->accessors.size()));

++             }

++             if (sparse.count > accessor.count

++                 || sparse.indicesByteOffset < 0 || sparse.valuesByteOffset < 0) {

++                 return setError(QStringLiteral("Accessor %1 has an invalid sparse count or byte offset")

++                                         .arg(document->accessors.size()));

++             }

++             // Offsets kept out of the sums, like the buffer view check above

++             const BufferView &indicesView = document->bufferViews.at(sparse.indicesBufferView);

++             const BufferView &valuesView = document->bufferViews.at(sparse.valuesBufferView);

++             const qint64 indicesSpan =

++                     sparse.count * Accessor::componentByteSize(sparse.indicesComponentType);

++             const qint64 valuesSpan = sparse.count * accessor.elementByteSize();

++             if (indicesSpan > indicesView.byteLength

++                 || sparse.indicesByteOffset > indicesView.byteLength - indicesSpan

++                 || valuesSpan > valuesView.byteLength

++                 || sparse.valuesByteOffset > valuesView.byteLength - valuesSpan) {

++                 return setError(

++                         QStringLiteral("Accessor %1 sparse data extends past the end of its buffer view")

++                                 .arg(document->accessors.size()));

++             }

++             accessor.sparse = sparse;

++         }

++

++         if (accessor.bufferView >= document->bufferViews.size())

++             return setError(

++                     QStringLiteral("Accessor %1 references invalid buffer view %2")

++                             .arg(document->accessors.size()).arg(accessor.bufferView));

++         if (accessor.bufferView >= 0) {

++             const BufferView &view = document->bufferViews.at(accessor.bufferView);

++             const qint64 elementSize = accessor.elementByteSize();

++             const qint64 stride = view.byteStride > 0 ? view.byteStride : elementSize;

++             // Offset kept out of the sum, like the buffer view check above

++             const qint64 span = (accessor.count - 1) * stride + elementSize;

++             if (accessor.count > 0

++                 && (span > view.byteLength || accessor.byteOffset > view.byteLength - span))

++                 return setError(QStringLiteral("Accessor %1 extends past the end of buffer view %2")

++                                         .arg(document->accessors.size())

++                                         .arg(accessor.bufferView));

++         } else {

++             // An accessor without a buffer view is read as all zeros, so no

++             // buffer bounds its size. The element cap above keeps this product

++             // from overflowing, but 256M elements of MAT4 would still be a

++             // 16 GB allocation, so bound the byte count as well.

++             constexpr qint64 maxSyntheticAccessorBytes = qint64(256) * 1024 * 1024;

++             if (accessor.count * accessor.elementByteSize() > maxSyntheticAccessorBytes)

++                 return setError(QStringLiteral("Accessor %1 has no buffer view and an unreasonably large count")

++                                         .arg(document->accessors.size()));

++         }

++         document->accessors.append(accessor);

++     }

++

++     // images

++     const QJsonArray images = root.value(QLatin1String("images")).toArray();

++     for (const auto &value : images) {

++         const QJsonObject object = value.toObject();

++         Image image;

++         image.uri = object.value(QLatin1String("uri")).toString();

++         image.bufferView = object.value(QLatin1String("bufferView")).toInt(-1);

++         image.mimeType = object.value(QLatin1String("mimeType")).toString();

++         image.name = object.value(QLatin1String("name")).toString();

++         if (image.bufferView >= document->bufferViews.size())

++             return setError(QStringLiteral("Image %1 references invalid buffer view %2")

++                             .arg(document->images.size()).arg(image.bufferView));

++         document->images.append(image);

++     }

++

++     // samplers

++     const QJsonArray samplers = root.value(QLatin1String("samplers")).toArray();

++     for (const auto &value : samplers) {

++         const QJsonObject object = value.toObject();

++         Sampler sampler;

++         sampler.magFilter = object.value(QLatin1String("magFilter")).toInt(0);

++         sampler.minFilter = object.value(QLatin1String("minFilter")).toInt(0);

++         sampler.wrapS = object.value(QLatin1String("wrapS")).toInt(Sampler::Repeat);

++         sampler.wrapT = object.value(QLatin1String("wrapT")).toInt(Sampler::Repeat);

++         sampler.name = object.value(QLatin1String("name")).toString();

++         document->samplers.append(sampler);

++     }

++

++     // textures

++     const QJsonArray textures = root.value(QLatin1String("textures")).toArray();

++     for (const auto &value : textures) {

++         const QJsonObject object = value.toObject();

++         Texture texture;

++         texture.sampler = object.value(QLatin1String("sampler")).toInt(-1);

++         texture.source = object.value(QLatin1String("source")).toInt(-1);

++         texture.name = object.value(QLatin1String("name")).toString();

++         texture.extensions = object.value(QLatin1String("extensions")).toObject();

++

++         const QJsonValue webpExt = texture.extensions.value(QLatin1String("EXT_texture_webp"));

++         if (webpExt.isObject())

++             texture.webpSource = webpExt.toObject().value(QLatin1String("source")).toInt(-1);

++

++         if (texture.sampler >= document->samplers.size())

++             return setError(QStringLiteral("Texture %1 references invalid sampler %2")

++                             .arg(document->textures.size()).arg(texture.sampler));

++         if (texture.source >= document->images.size() || texture.webpSource >= document->images.size())

++             return setError(QStringLiteral("Texture %1 references invalid image %2")

++                                     .arg(document->textures.size())

++                                     .arg(qMax(texture.source, texture.webpSource)));

++         document->textures.append(texture);

++     }

++

++     // materials

++     //

++     // Every texture reference goes through parseTexture() rather than

++     // parseTextureInfo() directly, so that the index is range checked in one

++     // place and a newly supported extension cannot forget to do it. The

++     // textures array is already parsed at this point.

++     int badTextureIndex = -1;

++     const auto parseTexture = [&](const QJsonObject &object,

++                                   const char *scaleOrStrengthKey = nullptr) {

++         const TextureInfo info = parseTextureInfo(object, scaleOrStrengthKey);

++         if (info.index >= document->textures.size())

++             badTextureIndex = info.index;

++         return info;

++     };

++

++     const QJsonArray materials = root.value(QLatin1String("materials")).toArray();

++     for (const auto &value : materials) {

++         const QJsonObject object = value.toObject();

++         Material material;

++         material.name = object.value(QLatin1String("name")).toString();

++

++         const QJsonValue pbrValue = object.value(QLatin1String("pbrMetallicRoughness"));

++         if (pbrValue.isObject()) {

++             const QJsonObject pbr = pbrValue.toObject();

++             material.baseColorFactor =

++                     toVector4D(pbr.value(QLatin1String("baseColorFactor")).toArray(), material.baseColorFactor);

++             material.baseColorTexture = parseTexture(pbr.value(QLatin1String("baseColorTexture")).toObject());

++             material.metallicFactor = float(pbr.value(QLatin1String("metallicFactor")).toDouble(1.0));

++             material.roughnessFactor = float(pbr.value(QLatin1String("roughnessFactor")).toDouble(1.0));

++             material.metallicRoughnessTexture =

++                     parseTexture(pbr.value(QLatin1String("metallicRoughnessTexture")).toObject());

++         }

++

++         material.normalTexture = parseTexture(object.value(QLatin1String("normalTexture")).toObject(), "scale");

++         material.occlusionTexture =

++                 parseTexture(object.value(QLatin1String("occlusionTexture")).toObject(), "strength");

++         material.emissiveTexture = parseTexture(object.value(QLatin1String("emissiveTexture")).toObject());

++         material.emissiveFactor =

++                 toVector3D(object.value(QLatin1String("emissiveFactor")).toArray(), material.emissiveFactor);

++

++         const QString alphaMode = object.value(QLatin1String("alphaMode")).toString();

++         if (alphaMode == QLatin1String("MASK"))

++             material.alphaMode = Material::AlphaMode::Mask;

++         else if (alphaMode == QLatin1String("BLEND"))

++             material.alphaMode = Material::AlphaMode::Blend;

++         material.alphaCutoff = float(object.value(QLatin1String("alphaCutoff")).toDouble(0.5));

++         material.doubleSided = object.value(QLatin1String("doubleSided")).toBool(false);

++

++         material.extensions = object.value(QLatin1String("extensions")).toObject();

++         const QJsonObject &ext = material.extensions;

++

++         material.unlit = ext.contains(QLatin1String("KHR_materials_unlit"));

++

++         const QJsonValue sgValue = ext.value(QLatin1String("KHR_materials_pbrSpecularGlossiness"));

++         if (sgValue.isObject()) {

++             const QJsonObject sg = sgValue.toObject();

++             Material::SpecularGlossiness specularGlossiness;

++             specularGlossiness.diffuseFactor = toVector4D(sg.value(QLatin1String("diffuseFactor")).toArray(),

++                                                           specularGlossiness.diffuseFactor);

++             specularGlossiness.diffuseTexture = parseTexture(sg.value(QLatin1String("diffuseTexture")).toObject());

++             specularGlossiness.specularFactor = toVector3D(sg.value(QLatin1String("specularFactor")).toArray(),

++                                                            specularGlossiness.specularFactor);

++             specularGlossiness.glossinessFactor = float(sg.value(QLatin1String("glossinessFactor")).toDouble(1.0));

++             specularGlossiness.specularGlossinessTexture = parseTexture(

++                     sg.value(QLatin1String("specularGlossinessTexture")).toObject());

++             material.specularGlossiness = specularGlossiness;

++         }

++

++         const QJsonValue ccValue = ext.value(QLatin1String("KHR_materials_clearcoat"));

++         if (ccValue.isObject()) {

++             const QJsonObject cc = ccValue.toObject();

++             Material::Clearcoat clearcoat;

++             clearcoat.clearcoatFactor = float(cc.value(QLatin1String("clearcoatFactor")).toDouble(0.0));

++             clearcoat.clearcoatTexture = parseTexture(cc.value(QLatin1String("clearcoatTexture")).toObject());

++             clearcoat.clearcoatRoughnessFactor =

++                     float(cc.value(QLatin1String("clearcoatRoughnessFactor")).toDouble(0.0));

++             clearcoat.clearcoatRoughnessTexture =

++                     parseTexture(cc.value(QLatin1String("clearcoatRoughnessTexture")).toObject());

++             clearcoat.clearcoatNormalTexture =

++                     parseTexture(cc.value(QLatin1String("clearcoatNormalTexture")).toObject(), "scale");

++             material.clearcoat = clearcoat;

++         }

++

++         const QJsonValue trValue = ext.value(QLatin1String("KHR_materials_transmission"));

++         if (trValue.isObject()) {

++             const QJsonObject tr = trValue.toObject();

++             Material::Transmission transmission;

++             transmission.transmissionFactor = float(tr.value(QLatin1String("transmissionFactor")).toDouble(0.0));

++             transmission.transmissionTexture =

++                     parseTexture(tr.value(QLatin1String("transmissionTexture")).toObject());

++             material.transmission = transmission;

++         }

++

++         const QJsonValue volValue = ext.value(QLatin1String("KHR_materials_volume"));

++         if (volValue.isObject()) {

++             const QJsonObject vol = volValue.toObject();

++             Material::Volume volume;

++             volume.thicknessFactor = float(vol.value(QLatin1String("thicknessFactor")).toDouble(0.0));

++             volume.thicknessTexture = parseTexture(vol.value(QLatin1String("thicknessTexture")).toObject());

++             volume.attenuationDistance = float(vol.value(QLatin1String("attenuationDistance")).toDouble(0.0));

++             volume.attenuationColor =

++                     toVector3D(vol.value(QLatin1String("attenuationColor")).toArray(), volume.attenuationColor);

++             material.volume = volume;

++         }

++

++         const QJsonValue iorValue = ext.value(QLatin1String("KHR_materials_ior"));

++         if (iorValue.isObject())

++             material.ior = float(iorValue.toObject().value(QLatin1String("ior")).toDouble(1.5));

++

++         const QJsonValue esValue = ext.value(QLatin1String("KHR_materials_emissive_strength"));

++         if (esValue.isObject())

++             material.emissiveStrength =

++                     float(esValue.toObject().value(QLatin1String("emissiveStrength")).toDouble(1.0));

++

++         const QJsonValue spValue = ext.value(QLatin1String("KHR_materials_specular"));

++         if (spValue.isObject()) {

++             const QJsonObject sp = spValue.toObject();

++             Material::Specular specular;

++             specular.specularFactor = float(sp.value(QLatin1String("specularFactor")).toDouble(1.0));

++             specular.specularTexture = parseTexture(sp.value(QLatin1String("specularTexture")).toObject());

++             specular.specularColorFactor = toVector3D(sp.value(QLatin1String("specularColorFactor")).toArray(),

++                                                       specular.specularColorFactor);

++             specular.specularColorTexture =

++                     parseTexture(sp.value(QLatin1String("specularColorTexture")).toObject());

++             material.specular = specular;

++         }

++

++         const QJsonValue shValue = ext.value(QLatin1String("KHR_materials_sheen"));

++         if (shValue.isObject()) {

++             const QJsonObject sh = shValue.toObject();

++             Material::Sheen sheen;

++             sheen.sheenColorFactor = toVector3D(sh.value(QLatin1String("sheenColorFactor")).toArray(), sheen.sheenColorFactor);

++             sheen.sheenColorTexture = parseTexture(sh.value(QLatin1String("sheenColorTexture")).toObject());

++             sheen.sheenRoughnessFactor = float(sh.value(QLatin1String("sheenRoughnessFactor")).toDouble(0.0));

++             sheen.sheenRoughnessTexture = parseTexture(sh.value(QLatin1String("sheenRoughnessTexture")).toObject());

++             material.sheen = sheen;

++         }

++

++         const QJsonValue anValue = ext.value(QLatin1String("KHR_materials_anisotropy"));

++         if (anValue.isObject()) {

++             const QJsonObject an = anValue.toObject();

++             Material::Anisotropy anisotropy;

++             anisotropy.anisotropyStrength = float(an.value(QLatin1String("anisotropyStrength")).toDouble(0.0));

++             anisotropy.anisotropyRotation = float(an.value(QLatin1String("anisotropyRotation")).toDouble(0.0));

++             anisotropy.anisotropyTexture = parseTexture(an.value(QLatin1String("anisotropyTexture")).toObject());

++             material.anisotropy = anisotropy;

++         }

++

++         const QJsonValue irValue = ext.value(QLatin1String("KHR_materials_iridescence"));

++         if (irValue.isObject()) {

++             const QJsonObject ir = irValue.toObject();

++             Material::Iridescence iridescence;

++             iridescence.iridescenceFactor = float(ir.value(QLatin1String("iridescenceFactor")).toDouble(0.0));

++             iridescence.iridescenceTexture = parseTexture(ir.value(QLatin1String("iridescenceTexture")).toObject());

++             iridescence.iridescenceIor = float(ir.value(QLatin1String("iridescenceIor")).toDouble(1.3));

++             iridescence.iridescenceThicknessMinimum = float(ir.value(QLatin1String("iridescenceThicknessMinimum")).toDouble(100.0));

++             iridescence.iridescenceThicknessMaximum = float(ir.value(QLatin1String("iridescenceThicknessMaximum")).toDouble(400.0));

++             iridescence.iridescenceThicknessTexture = parseTexture(

++                     ir.value(QLatin1String("iridescenceThicknessTexture")).toObject());

++             material.iridescence = iridescence;

++         }

++

++         const QJsonValue dispValue = ext.value(QLatin1String("KHR_materials_dispersion"));

++         if (dispValue.isObject())

++             material.dispersion = float(dispValue.toObject().value(QLatin1String("dispersion")).toDouble(0.0));

++

++         document->materials.append(material);

++     }

++

++     if (badTextureIndex >= 0)

++         return setError(QStringLiteral("Material references invalid texture %1").arg(badTextureIndex));

++

++     // meshes

++     const QJsonArray meshes = root.value(QLatin1String("meshes")).toArray();

++     for (const auto &value : meshes) {

++         const QJsonObject object = value.toObject();

++         Mesh mesh;

++         mesh.name = object.value(QLatin1String("name")).toString();

++         const QJsonArray weights = object.value(QLatin1String("weights")).toArray();

++         for (const auto &w : weights)

++             mesh.weights.append(float(w.toDouble()));

++

++         const QJsonArray primitives = object.value(QLatin1String("primitives")).toArray();

++         for (const auto &primitiveValue : primitives) {

++             const QJsonObject primitiveObject = primitiveValue.toObject();

++             MeshPrimitive primitive;

++             const QJsonObject attributes = primitiveObject.value(QLatin1String("attributes")).toObject();

++             for (auto it = attributes.constBegin(); it != attributes.constEnd(); ++it)

++                 primitive.attributes.insert(it.key().toUtf8(), it.value().toInt(-1));

++             primitive.indices = primitiveObject.value(QLatin1String("indices")).toInt(-1);

++             primitive.material = primitiveObject.value(QLatin1String("material")).toInt(-1);

++             primitive.mode = primitiveObject.value(QLatin1String("mode")).toInt(MeshPrimitive::Triangles);

++             const QJsonArray targets = primitiveObject.value(QLatin1String("targets")).toArray();

++             for (const auto &targetValue : targets) {

++                 const QJsonObject targetObject = targetValue.toObject();

++                 QHash<QByteArray, int> target;

++                 for (auto it = targetObject.constBegin(); it != targetObject.constEnd(); ++it)

++                     target.insert(it.key().toUtf8(), it.value().toInt(-1));

++                 primitive.targets.append(target);

++             }

++             primitive.extensions = primitiveObject.value(QLatin1String("extensions")).toObject();

++

++             const QJsonValue variantsExt = primitive.extensions.value(QLatin1String("KHR_materials_variants"));

++             if (variantsExt.isObject()) {

++                 const QJsonArray mappings = variantsExt.toObject().value(QLatin1String("mappings")).toArray();

++                 for (const auto &mappingValue : mappings) {

++                     const QJsonObject mappingObject = mappingValue.toObject();

++                     MeshPrimitive::VariantMapping mapping;

++                     mapping.material = mappingObject.value(QLatin1String("material")).toInt(-1);

++                     if (mapping.material < 0 || mapping.material >= document->materials.size()) {

++                         return setError(

++                                 QStringLiteral("Mesh %1 primitive variant mapping references invalid material %2")

++                                         .arg(document->meshes.size())

++                                         .arg(mapping.material));

++                     }

++                     const QJsonArray mappingVariants = mappingObject.value(QLatin1String("variants")).toArray();

++                     for (const auto &variantValue : mappingVariants) {

++                         const int variant = variantValue.toInt(-1);

++                         if (variant < 0 || variant >= document->materialVariants.size()) {

++                             return setError(

++                                     QStringLiteral("Mesh %1 primitive variant mapping references invalid variant %2")

++                                             .arg(document->meshes.size())

++                                             .arg(variant));

++                         }

++                         mapping.variants.append(variant);

++                     }

++                     primitive.variantMappings.append(mapping);

++                 }

++             }

++

++             // Structural validation of accessor references. As everywhere in

++             // this parser, any negative index means "unset": the glTF defaults

++             // are -1, the readers return nothing for a negative index, and so

++             // only the upper bound needs checking here.

++             const auto checkAccessor = [&](int accessor, const char *what) {

++                 if (accessor >= document->accessors.size())

++                     return setError(QStringLiteral("Mesh %1 primitive references invalid %2 accessor %3")

++                                             .arg(document->meshes.size()).arg(QLatin1String(what)).arg(accessor));

++                 return true;

++             };

++             for (auto it = primitive.attributes.constBegin(); it != primitive.attributes.constEnd(); ++it) {

++                 if (!checkAccessor(it.value(), it.key().constData()))

++                     return false;

++             }

++             if (primitive.indices >= 0 && !checkAccessor(primitive.indices, "index"))

++                 return false;

++             if (primitive.material >= document->materials.size())

++                 return setError(QStringLiteral("Mesh %1 primitive references invalid material %2")

++                                         .arg(document->meshes.size())

++                                         .arg(primitive.material));

++

++             mesh.primitives.append(primitive);

++         }

++         if (mesh.primitives.isEmpty())

++             qCWarning(lcQuick3DGltf) << "Mesh" << document->meshes.size() << "has no primitives";

++         document->meshes.append(mesh);

++     }

++

++     // cameras

++     const QJsonArray cameras = root.value(QLatin1String("cameras")).toArray();

++     for (const auto &value : cameras) {

++         const QJsonObject object = value.toObject();

++         Camera camera;

++         camera.name = object.value(QLatin1String("name")).toString();

++         const QString type = object.value(QLatin1String("type")).toString();

++         if (type == QLatin1String("orthographic")) {

++             camera.type = Camera::Type::Orthographic;

++             const QJsonObject ortho = object.value(QLatin1String("orthographic")).toObject();

++             camera.xmag = float(ortho.value(QLatin1String("xmag")).toDouble());

++             camera.ymag = float(ortho.value(QLatin1String("ymag")).toDouble());

++             camera.znear = float(ortho.value(QLatin1String("znear")).toDouble());

++             camera.zfar = float(ortho.value(QLatin1String("zfar")).toDouble());

++         } else {

++             camera.type = Camera::Type::Perspective;

++             const QJsonObject perspective = object.value(QLatin1String("perspective")).toObject();

++             camera.aspectRatio = float(perspective.value(QLatin1String("aspectRatio")).toDouble(0.0));

++             camera.yfov = float(perspective.value(QLatin1String("yfov")).toDouble());

++             camera.znear = float(perspective.value(QLatin1String("znear")).toDouble());

++             camera.zfar = float(perspective.value(QLatin1String("zfar")).toDouble(0.0));

++         }

++         document->cameras.append(camera);

++     }

++

++     // KHR_lights_punctual (document level)

++     {

++         const QJsonValue lightsExt = document->rootExtensions.value(QLatin1String("KHR_lights_punctual"));

++         if (lightsExt.isObject()) {

++             const QJsonArray lights = lightsExt.toObject().value(QLatin1String("lights")).toArray();

++             for (const auto &value : lights) {

++                 const QJsonObject object = value.toObject();

++                 Light light;

++                 light.name = object.value(QLatin1String("name")).toString();

++                 const QString type = object.value(QLatin1String("type")).toString();

++                 if (type == QLatin1String("point"))

++                     light.type = Light::Type::Point;

++                 else if (type == QLatin1String("spot"))

++                     light.type = Light::Type::Spot;

++                 else

++                     light.type = Light::Type::Directional;

++                 light.color = toVector3D(object.value(QLatin1String("color")).toArray(), light.color);

++                 light.intensity = float(object.value(QLatin1String("intensity")).toDouble(1.0));

++                 light.range = float(object.value(QLatin1String("range")).toDouble(0.0));

++                 if (light.type == Light::Type::Spot) {

++                     const QJsonObject spot = object.value(QLatin1String("spot")).toObject();

++                     light.innerConeAngle = float(spot.value(QLatin1String("innerConeAngle")).toDouble(0.0));

++                     light.outerConeAngle = float(spot.value(QLatin1String("outerConeAngle")).toDouble(M_PI_4));

++                 }

++                 document->lights.append(light);

++             }

++         }

++     }

++

++     // nodes

++     const QJsonArray nodes = root.value(QLatin1String("nodes")).toArray();

++     for (const auto &value : nodes) {

++         const QJsonObject object = value.toObject();

++         Node node;

++         node.name = object.value(QLatin1String("name")).toString();

++         const QJsonArray children = object.value(QLatin1String("children")).toArray();

++         for (const auto &child : children)

++             node.children.append(child.toInt(-1));

++         node.mesh = object.value(QLatin1String("mesh")).toInt(-1);

++         node.skin = object.value(QLatin1String("skin")).toInt(-1);

++         node.camera = object.value(QLatin1String("camera")).toInt(-1);

++

++         const QJsonValue matrixValue = object.value(QLatin1String("matrix"));

++         if (matrixValue.isArray()) {

++             const QJsonArray m = matrixValue.toArray();

++             if (m.size() == 16) {

++                 float values[16];

++                 for (int i = 0; i < 16; ++i)

++                     values[i] = float(m.at(i).toDouble());

++                 // glTF matrices are column-major; QMatrix4x4(float*) is row-major

++                 node.matrix = QMatrix4x4(values).transposed();

++                 node.hasMatrix = true;

++             }

++         }

++         node.translation = toVector3D(object.value(QLatin1String("translation")).toArray(), node.translation);

++         const QJsonArray rotation = object.value(QLatin1String("rotation")).toArray();

++         if (rotation.size() == 4) {

++             // glTF quaternions are (x, y, z, w)

++             node.rotation = QQuaternion(float(rotation.at(3).toDouble()), float(rotation.at(0).toDouble()),

++                                         float(rotation.at(1).toDouble()), float(rotation.at(2).toDouble()));

++         }

++         node.scale = toVector3D(object.value(QLatin1String("scale")).toArray(), node.scale);

++         const QJsonArray weights = object.value(QLatin1String("weights")).toArray();

++         for (const auto &w : weights)

++             node.weights.append(float(w.toDouble()));

++         node.extensions = object.value(QLatin1String("extensions")).toObject();

++

++         const QJsonValue lightExt = node.extensions.value(QLatin1String("KHR_lights_punctual"));

++         if (lightExt.isObject())

++             node.light = lightExt.toObject().value(QLatin1String("light")).toInt(-1);

++

++         const QJsonValue visibilityExt = node.extensions.value(QLatin1String("KHR_node_visibility"));

++         if (visibilityExt.isObject())

++             node.visible = visibilityExt.toObject().value(QLatin1String("visible")).toBool(true);

++

++         const QJsonValue instancingExt = node.extensions.value(QLatin1String("EXT_mesh_gpu_instancing"));

++         if (instancingExt.isObject()) {

++             const QJsonObject instanceAttributes =

++                     instancingExt.toObject().value(QLatin1String("attributes")).toObject();

++             for (auto it = instanceAttributes.constBegin(); it != instanceAttributes.constEnd(); ++it) {

++                 const int accessor = it.value().toInt(-1);

++                 if (accessor < 0 || accessor >= document->accessors.size()) {

++                     return setError(QStringLiteral("Node %1 instance attribute %2 references invalid accessor %3")

++                                             .arg(document->nodes.size()).arg(it.key()).arg(accessor));

++                 }

++                 if (it.key() == QLatin1String("TRANSLATION"))

++                     node.instanceTranslation = accessor;

++                 else if (it.key() == QLatin1String("ROTATION"))

++                     node.instanceRotation = accessor;

++                 else if (it.key() == QLatin1String("SCALE"))

++                     node.instanceScale = accessor;

++                 else

++                     qCWarning(lcQuick3DGltf) << "Ignoring unsupported instance attribute" << it.key();

++             }

++             node.hasInstancing = node.instanceTranslation >= 0 || node.instanceRotation >= 0

++                     || node.instanceScale >= 0;

++         }

++

++         if (node.mesh >= document->meshes.size())

++             return setError(QStringLiteral("Node %1 references invalid mesh %2")

++                             .arg(document->nodes.size()).arg(node.mesh));

++         if (node.camera >= document->cameras.size())

++             return setError(QStringLiteral("Node %1 references invalid camera %2")

++                             .arg(document->nodes.size()).arg(node.camera));

++         if (node.light >= document->lights.size())

++             return setError(QStringLiteral("Node %1 references invalid light %2")

++                             .arg(document->nodes.size()).arg(node.light));

++         document->nodes.append(node);

++     }

++

++     // Validate node graph references (children and skins can be forward

++     // references). The specification requires the hierarchy to be a forest,

++     // and consumers that recurse over the graph rely on that to be safe from

++     // cycles and exponential blowup, so the shape is repaired here rather than

++     // left for them to cope with.

++     const int nodeCount = document->nodes.size();

++     QVarLengthArray<int, 64> parentCount(nodeCount);

++     std::fill(parentCount.begin(), parentCount.end(), 0);

++     for (int i = 0; i < nodeCount; ++i) {

++         Node &node = document->nodes[i];

++         for (qsizetype c = 0; c < node.children.size(); ++c) {

++             const int child = node.children.at(c);

++             if (child < 0 || child >= nodeCount)

++                 return setError(QStringLiteral("Node %1 references invalid child node %2").arg(i).arg(child));

++             if (++parentCount[child] > 1) {

++                 // A second parent cannot be represented at all: a node

++                 // occupies exactly one place in a scene graph. Keep the first

++                 // edge and drop this one, so the rest of the asset still

++                 // loads.

++                 qCWarning(lcQuick3DGltf) << "Node" << child

++                                          << "has more than one parent; ignoring the edge from node" << i;

++                 --parentCount[child];

++                 node.children.removeAt(c--);

++             }

++         }

++     }

++     // With single parents the only remaining hazards are parentless cycles

++     // and excessive depth; both are caught by walking up each node's parent

++     // chain, memoizing the depths so every edge is visited only once.

++     {

++         constexpr int maxNodeDepth = 4096;

++         QVarLengthArray<int, 64> parent(nodeCount);

++         std::fill(parent.begin(), parent.end(), -1);

++         for (int i = 0; i < nodeCount; ++i) {

++             for (int child : document->nodes.at(i).children)

++                 parent[child] = i;

++         }

++         QVarLengthArray<int, 64> depth(nodeCount);

++         std::fill(depth.begin(), depth.end(), -1);

++         QVarLengthArray<int, 64> chain;

++         for (int i = 0; i < nodeCount; ++i) {

++             chain.clear();

++             int n = i;

++             while (n >= 0 && depth[n] < 0 && chain.size() <= nodeCount) {

++                 chain.append(n);

++                 n = parent[n];

++             }

++             if (chain.size() > nodeCount)

++                 return setError(QStringLiteral("Node hierarchy contains a cycle"));

++             int d = n >= 0 ? depth[n] : 0;

++             for (auto it = chain.rbegin(); it != chain.rend(); ++it)

++                 depth[*it] = ++d;

++             if (d > maxNodeDepth)

++                 return setError(QStringLiteral("Node hierarchy is deeper than %1").arg(maxNodeDepth));

++         }

++     }

++

++     // skins

++     const QJsonArray skins = root.value(QLatin1String("skins")).toArray();

++     for (const auto &value : skins) {

++         const QJsonObject object = value.toObject();

++         Skin skin;

++         skin.name = object.value(QLatin1String("name")).toString();

++         skin.inverseBindMatrices = object.value(QLatin1String("inverseBindMatrices")).toInt(-1);

++         skin.skeleton = object.value(QLatin1String("skeleton")).toInt(-1);

++         const QJsonArray joints = object.value(QLatin1String("joints")).toArray();

++         for (const auto &joint : joints)

++             skin.joints.append(joint.toInt(-1));

++

++         if (skin.inverseBindMatrices >= document->accessors.size())

++             return setError(QStringLiteral("Skin %1 references invalid accessor %2")

++                             .arg(document->skins.size()).arg(skin.inverseBindMatrices));

++         for (int joint : std::as_const(skin.joints)) {

++             if (joint < 0 || joint >= nodeCount)

++                 return setError(QStringLiteral("Skin %1 references invalid joint node %2")

++                                 .arg(document->skins.size()).arg(joint));

++         }

++         document->skins.append(skin);

++     }

++     for (int i = 0; i < nodeCount; ++i) {

++         if (document->nodes.at(i).skin >= document->skins.size())

++             return setError(QStringLiteral("Node %1 references invalid skin %2")

++                             .arg(i).arg(document->nodes.at(i).skin));

++     }

++

++     // animations

++     const QJsonArray animations = root.value(QLatin1String("animations")).toArray();

++     for (const auto &value : animations) {

++         const QJsonObject object = value.toObject();

++         Animation animation;

++         animation.name = object.value(QLatin1String("name")).toString();

++

++         const QJsonArray animationSamplers = object.value(QLatin1String("samplers")).toArray();

++         for (const auto &samplerValue : animationSamplers) {

++             const QJsonObject samplerObject = samplerValue.toObject();

++             AnimationSampler sampler;

++             sampler.input = samplerObject.value(QLatin1String("input")).toInt(-1);

++             sampler.output = samplerObject.value(QLatin1String("output")).toInt(-1);

++             const QString interpolation = samplerObject.value(QLatin1String("interpolation")).toString();

++             if (interpolation == QLatin1String("STEP"))

++                 sampler.interpolation = AnimationSampler::Interpolation::Step;

++             else if (interpolation == QLatin1String("CUBICSPLINE"))

++                 sampler.interpolation = AnimationSampler::Interpolation::CubicSpline;

++             if (sampler.input < 0 || sampler.input >= document->accessors.size()

++                 || sampler.output < 0 || sampler.output >= document->accessors.size()) {

++                 return setError(

++                         QStringLiteral("Animation %1 sampler references an invalid accessor")

++                                 .arg(document->animations.size()));

++             }

++             animation.samplers.append(sampler);

++         }

++

++         const QJsonArray channels = object.value(QLatin1String("channels")).toArray();

++         for (const auto &channelValue : channels) {

++             const QJsonObject channelObject = channelValue.toObject();

++             AnimationChannel channel;

++             channel.sampler = channelObject.value(QLatin1String("sampler")).toInt(-1);

++             const QJsonObject target = channelObject.value(QLatin1String("target")).toObject();

++             channel.targetNode = target.value(QLatin1String("node")).toInt(-1);

++             const QString path = target.value(QLatin1String("path")).toString();

++             if (path == QLatin1String("rotation"))

++                 channel.path = AnimationChannel::Path::Rotation;

++             else if (path == QLatin1String("scale"))

++                 channel.path = AnimationChannel::Path::Scale;

++             else if (path == QLatin1String("weights"))

++                 channel.path = AnimationChannel::Path::Weights;

++             else if (path != QLatin1String("translation")) {

++                 qCWarning(lcQuick3DGltf) << "Ignoring animation channel with unsupported path" << path;

++                 continue;

++             }

++             if (channel.sampler < 0 || channel.sampler >= animation.samplers.size())

++                 return setError(QStringLiteral("Animation %1 channel references invalid sampler %2")

++                                         .arg(document->animations.size())

++                                         .arg(channel.sampler));

++             if (channel.targetNode >= nodeCount)

++                 return setError(QStringLiteral("Animation %1 channel references invalid node %2")

++                                         .arg(document->animations.size())

++                                         .arg(channel.targetNode));

++             animation.channels.append(channel);

++         }

++

++         document->animations.append(animation);

++     }

++

++     // scenes

++     const QJsonArray scenes = root.value(QLatin1String("scenes")).toArray();

++     for (const auto &value : scenes) {

++         const QJsonObject object = value.toObject();

++         Scene scene;

++         scene.name = object.value(QLatin1String("name")).toString();

++         QSet<int> seenRoots;

++         const QJsonArray sceneNodes = object.value(QLatin1String("nodes")).toArray();

++         for (const auto &nodeIndex : sceneNodes) {

++             const int index = nodeIndex.toInt(-1);

++             if (index < 0 || index >= nodeCount)

++                 return setError(QStringLiteral("Scene %1 references invalid node %2")

++                                 .arg(document->scenes.size()).arg(index));

++             // Scene nodes must be distinct root nodes; a repeated node, or one

++             // that is also somebody's child, would have its subtree emitted

++             // more than once. Skip the offending entry rather than failing, so

++             // that the scene still contains everything it should, once.

++             if (parentCount[index] != 0 || seenRoots.contains(index)) {

++                 qCWarning(lcQuick3DGltf) << "Scene" << document->scenes.size() << "references node" << index

++                                          << "which is not a unique root node; ignoring it";

++                 continue;

++             }

++             seenRoots.insert(index);

++             scene.nodes.append(index);

++         }

++         document->scenes.append(scene);

++     }

++     document->scene = root.value(QLatin1String("scene")).toInt(-1);

++     if (document->scene >= document->scenes.size())

++         return setError(QStringLiteral("Document references invalid default scene %1").arg(document->scene));

++

++     return true;

++ }

++

++ QT_END_NAMESPACE

Revision control