qt/qtquick3d/tests/auto/gltf/tst_qssggltfparser.cpp

Revision control

Copy as Markdown

// Copyright (C) 2026 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QtTest/QtTest>
#include <QtQuick3DGltf/private/qssggltfaccessorreader_p.h>
#include <QtQuick3DGltf/private/qssggltfparser_p.h>
#include <QtQuick3DGltf/private/qssggltfresourceresolver_p.h>
#include <QtCore/qendian.h>
#include <QtCore/qmath.h>
#include <QtCore/qfile.h>
class tst_qssggltfparser : public QObject
{
Q_OBJECT
private slots:
void externalBuffer();
void embeddedBuffer();
void glbContainer();
void glbBadMagic();
void glbTruncated();
void glbUnsupportedVersion();
void dataUriDecoding();
void requiredExtensionGate();
void materials();
void lightsAndCameras();
void sparseAccessorStructure();
void structuralValidation();
void hostileInputValidation();
void nodeVisibilityAndWebp();
void meshoptCompression();
void meshGpuInstancing();
void materialVariants();
void readAccessorData();
void readSparseAccessor();
void readInterleavedAccessor();
void readNormalizedAccessor();
private:
QString testFile(const QString &name) const
{
return QFINDTESTDATA(QStringLiteral("data/") + name);
}
QByteArray makeGlb(const QByteArray &json, const QByteArray &bin = {}) const;
};
// Builds a GLB container from a JSON chunk and an optional BIN chunk
QByteArray tst_qssggltfparser::makeGlb(const QByteArray &json, const QByteArray &bin) const
{
const auto appendUInt32 = [](QByteArray &out, quint32 value) {
quint32 le;
qToLittleEndian(value, &le);
out.append(reinterpret_cast<const char *>(&le), 4);
};
const auto padded = [](QByteArray chunk, char padByte) {
while (chunk.size() % 4)
chunk.append(padByte);
return chunk;
};
const QByteArray jsonChunk = padded(json, ' ');
const QByteArray binChunk = padded(bin, '\0');
QByteArray out;
appendUInt32(out, 0x46546C67); // magic
appendUInt32(out, 2); // version
quint32 total = 12 + 8 + jsonChunk.size();
if (!bin.isEmpty())
total += 8 + binChunk.size();
appendUInt32(out, total);
appendUInt32(out, jsonChunk.size());
appendUInt32(out, 0x4E4F534A); // 'JSON'
out += jsonChunk;
if (!bin.isEmpty()) {
appendUInt32(out, binChunk.size());
appendUInt32(out, 0x004E4942); // 'BIN\0'
out += binChunk;
}
return out;
}
void tst_qssggltfparser::externalBuffer()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parseFile(testFile(QStringLiteral("triangle.gltf")), &document),
qPrintable(parser.errorMessage()));
QCOMPARE(document.asset.version, QStringLiteral("2.0"));
QCOMPARE(document.buffers.size(), 1);
QCOMPARE(document.buffers.first().data.size(), 44);
QCOMPARE(document.bufferViews.size(), 2);
QCOMPARE(document.accessors.size(), 2);
QCOMPARE(document.accessors.at(0).type, QSSGGltf::Accessor::Type::Vec3);
QCOMPARE(document.accessors.at(0).componentType, QSSGGltf::Accessor::ComponentType::Float);
QCOMPARE(document.accessors.at(0).count, 3);
QCOMPARE(document.accessors.at(1).componentType, QSSGGltf::Accessor::ComponentType::UnsignedShort);
QCOMPARE(document.meshes.size(), 1);
QCOMPARE(document.meshes.first().primitives.size(), 1);
QCOMPARE(document.meshes.first().primitives.first().attributes.value("POSITION"), 0);
QCOMPARE(document.meshes.first().primitives.first().indices, 1);
QCOMPARE(document.nodes.size(), 1);
QCOMPARE(document.nodes.first().translation, QVector3D(1, 2, 3));
QCOMPARE(document.scene, 0);
QCOMPARE(document.scenes.first().nodes, QList<int>({ 0 }));
// Buffer contents: second vertex is (1, 0, 0)
const float *positions = reinterpret_cast<const float *>(document.buffers.first().data.constData());
QCOMPARE(positions[3], 1.0f);
}
void tst_qssggltfparser::embeddedBuffer()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parseFile(testFile(QStringLiteral("triangle_embedded.gltf")), &document),
qPrintable(parser.errorMessage()));
QCOMPARE(document.buffers.first().data.size(), 44);
// The embedded buffer must decode to the same bytes as the external one
QFile binFile(testFile(QStringLiteral("triangle.bin")));
QVERIFY(binFile.open(QIODevice::ReadOnly));
QCOMPARE(document.buffers.first().data, binFile.readAll());
}
void tst_qssggltfparser::glbContainer()
{
QFile jsonFile(testFile(QStringLiteral("triangle_embedded.gltf")));
QVERIFY(jsonFile.open(QIODevice::ReadOnly));
const QByteArray glb = makeGlb(jsonFile.readAll());
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parse(glb, QString(), &document), qPrintable(parser.errorMessage()));
QCOMPARE(document.meshes.size(), 1);
// GLB with the buffer moved into the BIN chunk
QFile binFile(testFile(QStringLiteral("triangle.bin")));
QVERIFY(binFile.open(QIODevice::ReadOnly));
const QByteArray bin = binFile.readAll();
const QByteArray json = QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"byteLength\": 44 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteOffset\": 0, \"byteLength\": 36 } ],"
" \"accessors\": [ { \"bufferView\": 0, \"componentType\": 5126, \"count\": 3, \"type\": \"VEC3\" } ] }");
QVERIFY2(parser.parse(makeGlb(json, bin), QString(), &document), qPrintable(parser.errorMessage()));
QCOMPARE(document.buffers.first().data, bin);
}
void tst_qssggltfparser::glbBadMagic()
{
QByteArray glb = makeGlb(QByteArrayLiteral("{ \"asset\": { \"version\": \"2.0\" } }"));
glb[0] = 'X';
// Not GLB magic, so it falls through to JSON parsing and fails there
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY(!parser.parse(glb, QString(), &document));
QVERIFY(parser.errorMessage().contains(QStringLiteral("Invalid glTF JSON")));
}
void tst_qssggltfparser::glbTruncated()
{
const QByteArray glb = makeGlb(QByteArrayLiteral("{ \"asset\": { \"version\": \"2.0\" } }"));
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY(!parser.parse(glb.left(glb.size() - 8), QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("Truncated")), qPrintable(parser.errorMessage()));
}
void tst_qssggltfparser::glbUnsupportedVersion()
{
QByteArray glb = makeGlb(QByteArrayLiteral("{ \"asset\": { \"version\": \"2.0\" } }"));
glb[4] = 3; // container version
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY(!parser.parse(glb, QString(), &document));
QVERIFY(parser.errorMessage().contains(QStringLiteral("version")));
}
void tst_qssggltfparser::dataUriDecoding()
{
QCOMPARE(QSSGGltfResourceResolver::decodeDataUri(u"data:application/octet-stream;base64,SGVsbG8="),
QByteArrayLiteral("Hello"));
QCOMPARE(QSSGGltfResourceResolver::decodeDataUri(u"data:,Hello%20World"),
QByteArrayLiteral("Hello World"));
// A non-base64 payload carries arbitrary octets, not text. Decoding it via
// QString would turn every sequence that is not valid UTF-8 into U+FFFD,
// which changes the length as well as the contents, and a buffer whose
// length still passes its size check then loads silently corrupted.
QCOMPARE(QSSGGltfResourceResolver::decodeDataUri(u"data:,%FF%FE%00A"),
QByteArrayLiteral("\xff\xfe\x00" "A"));
QString error;
QVERIFY(QSSGGltfResourceResolver::decodeDataUri(u"data:application/octet-stream;base64", &error).isEmpty());
QVERIFY(!error.isEmpty());
QVERIFY(QSSGGltfResourceResolver::isDataUri(u"data:,x"));
QVERIFY(!QSSGGltfResourceResolver::isDataUri(u"buffer.bin"));
}
void tst_qssggltfparser::requiredExtensionGate()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY(!parser.parseFile(testFile(QStringLiteral("draco_required.gltf")), &document));
QCOMPARE(parser.errorMessage(),
QStringLiteral("Asset requires unsupported glTF extension 'KHR_draco_mesh_compression'"));
// The same extension only listed in extensionsUsed parses with a warning
const QByteArray json = QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"extensionsUsed\": [ \"KHR_texture_basisu\" ] }");
QVERIFY2(parser.parse(json, QString(), &document), qPrintable(parser.errorMessage()));
}
static bool specGlossOrUnlitHasBrdfExtensions(const QSSGGltf::Material &material)
{
return material.sheen.has_value() || material.anisotropy.has_value() || material.iridescence.has_value()
|| material.dispersion.has_value();
}
void tst_qssggltfparser::materials()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parseFile(testFile(QStringLiteral("material_extensions.gltf")), &document),
qPrintable(parser.errorMessage()));
QCOMPARE(document.materials.size(), 3);
const QSSGGltf::Material &full = document.materials.at(0);
QCOMPARE(full.name, QStringLiteral("full"));
QCOMPARE(full.baseColorFactor, QVector4D(0.8f, 0.6f, 0.4f, 1.0f));
QCOMPARE(full.metallicFactor, 0.7f);
QCOMPARE(full.roughnessFactor, 0.3f);
QCOMPARE(full.baseColorTexture.index, 0);
QVERIFY(full.baseColorTexture.transform.has_value());
QCOMPARE(full.baseColorTexture.transform->offset, QVector2D(0.25f, 0.5f));
QCOMPARE(full.baseColorTexture.transform->scale, QVector2D(2.0f, 3.0f));
QCOMPARE(full.normalTexture.scaleOrStrength, 0.9f);
QCOMPARE(full.occlusionTexture.scaleOrStrength, 0.8f);
QCOMPARE(full.emissiveFactor, QVector3D(0.1f, 0.2f, 0.3f));
QCOMPARE(full.alphaMode, QSSGGltf::Material::AlphaMode::Mask);
QCOMPARE(full.alphaCutoff, 0.25f);
QVERIFY(full.doubleSided);
QVERIFY(full.clearcoat.has_value());
QCOMPARE(full.clearcoat->clearcoatFactor, 0.6f);
QCOMPARE(full.clearcoat->clearcoatRoughnessFactor, 0.2f);
QVERIFY(full.transmission.has_value());
QCOMPARE(full.transmission->transmissionFactor, 0.75f);
QVERIFY(full.volume.has_value());
QCOMPARE(full.volume->thicknessFactor, 1.2f);
QCOMPARE(full.volume->attenuationDistance, 0.5f);
QCOMPARE(full.volume->attenuationColor, QVector3D(0.9f, 0.8f, 0.7f));
QVERIFY(full.ior.has_value());
QCOMPARE(*full.ior, 1.4f);
QVERIFY(full.emissiveStrength.has_value());
QCOMPARE(*full.emissiveStrength, 5.0f);
QVERIFY(full.specular.has_value());
QCOMPARE(full.specular->specularFactor, 0.5f);
QCOMPARE(full.specular->specularColorFactor, QVector3D(0.2f, 0.4f, 0.6f));
QVERIFY(full.sheen.has_value());
QCOMPARE(full.sheen->sheenColorFactor, QVector3D(0.3f, 0.5f, 0.7f));
QCOMPARE(full.sheen->sheenRoughnessFactor, 0.45f);
QCOMPARE(full.sheen->sheenColorTexture.index, 0);
QCOMPARE(full.sheen->sheenRoughnessTexture.index, 0);
QVERIFY(full.anisotropy.has_value());
QCOMPARE(full.anisotropy->anisotropyStrength, 0.65f);
// The document keeps the extension's radians; the converter is what turns
// it into the degrees the QML property uses
QCOMPARE(full.anisotropy->anisotropyRotation, qDegreesToRadians(90.0f));
QCOMPARE(full.anisotropy->anisotropyTexture.index, 0);
QVERIFY(full.iridescence.has_value());
QCOMPARE(full.iridescence->iridescenceFactor, 0.85f);
QCOMPARE(full.iridescence->iridescenceIor, 1.8f);
QCOMPARE(full.iridescence->iridescenceThicknessMinimum, 250.0f);
QCOMPARE(full.iridescence->iridescenceThicknessMaximum, 900.0f);
QCOMPARE(full.iridescence->iridescenceTexture.index, 0);
QCOMPARE(full.iridescence->iridescenceThicknessTexture.index, 0);
QVERIFY(full.dispersion.has_value());
QCOMPARE(*full.dispersion, 0.4f);
// A material without the extensions must leave every optional unset rather
// than defaulting the effects on
QVERIFY(!specGlossOrUnlitHasBrdfExtensions(document.materials.at(1)));
QVERIFY(!specGlossOrUnlitHasBrdfExtensions(document.materials.at(2)));
const QSSGGltf::Material &specGloss = document.materials.at(1);
QVERIFY(specGloss.specularGlossiness.has_value());
QCOMPARE(specGloss.specularGlossiness->diffuseFactor, QVector4D(0.5f, 0.5f, 0.5f, 1.0f));
QCOMPARE(specGloss.specularGlossiness->specularFactor, QVector3D(0.1f, 0.2f, 0.3f));
QCOMPARE(specGloss.specularGlossiness->glossinessFactor, 0.4f);
QVERIFY(document.materials.at(2).unlit);
// Sampler values
QCOMPARE(document.samplers.size(), 1);
QCOMPARE(document.samplers.first().magFilter, int(QSSGGltf::Sampler::Nearest));
QCOMPARE(document.samplers.first().minFilter, int(QSSGGltf::Sampler::LinearMipMapNearest));
QCOMPARE(document.samplers.first().wrapS, int(QSSGGltf::Sampler::ClampToEdge));
QCOMPARE(document.samplers.first().wrapT, int(QSSGGltf::Sampler::MirroredRepeat));
}
void tst_qssggltfparser::lightsAndCameras()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parseFile(testFile(QStringLiteral("material_extensions.gltf")), &document),
qPrintable(parser.errorMessage()));
QCOMPARE(document.lights.size(), 3);
QCOMPARE(document.lights.at(0).type, QSSGGltf::Light::Type::Directional);
QCOMPARE(document.lights.at(0).color, QVector3D(1.0f, 0.9f, 0.8f));
QCOMPARE(document.lights.at(0).intensity, 3.0f);
QCOMPARE(document.lights.at(1).type, QSSGGltf::Light::Type::Point);
QCOMPARE(document.lights.at(1).range, 10.0f);
QCOMPARE(document.lights.at(2).type, QSSGGltf::Light::Type::Spot);
QCOMPARE(document.lights.at(2).innerConeAngle, 0.2f);
QCOMPARE(document.lights.at(2).outerConeAngle, 0.5f);
QCOMPARE(document.nodes.at(0).light, 2);
QCOMPARE(document.nodes.at(1).camera, 0);
QCOMPARE(document.cameras.size(), 2);
QCOMPARE(document.cameras.at(0).type, QSSGGltf::Camera::Type::Perspective);
QCOMPARE(document.cameras.at(0).yfov, 0.66f);
QCOMPARE(document.cameras.at(0).zfar, 1000.0f);
QCOMPARE(document.cameras.at(1).type, QSSGGltf::Camera::Type::Orthographic);
QCOMPARE(document.cameras.at(1).xmag, 2.0f);
QCOMPARE(document.cameras.at(1).ymag, 1.5f);
}
void tst_qssggltfparser::sparseAccessorStructure()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parseFile(testFile(QStringLiteral("sparse.gltf")), &document),
qPrintable(parser.errorMessage()));
QCOMPARE(document.accessors.size(), 1);
const QSSGGltf::Accessor &accessor = document.accessors.first();
QVERIFY(accessor.sparse.has_value());
QCOMPARE(accessor.sparse->count, 2);
QCOMPARE(accessor.sparse->indicesBufferView, 1);
QCOMPARE(accessor.sparse->indicesComponentType, QSSGGltf::Accessor::ComponentType::UnsignedShort);
QCOMPARE(accessor.sparse->valuesBufferView, 2);
}
void tst_qssggltfparser::structuralValidation()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
// Accessor past the end of its buffer view
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"uri\": \"data:,0123456789\", \"byteLength\": 10 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteLength\": 10 } ],"
" \"accessors\": [ { \"bufferView\": 0, \"componentType\": 5126, \"count\": 3, \"type\": \"VEC3\" } ] }"),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("extends past")), qPrintable(parser.errorMessage()));
// Buffer view past the end of its buffer
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"uri\": \"data:,0123456789\", \"byteLength\": 10 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteOffset\": 8, \"byteLength\": 10 } ] }"),
QString(), &document));
// Node referencing an out-of-range mesh
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" }, \"nodes\": [ { \"mesh\": 7 } ] }"),
QString(), &document));
// Scene referencing an out-of-range node
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" }, \"scenes\": [ { \"nodes\": [3] } ], \"scene\": 0 }"),
QString(), &document));
// glTF 1.x is rejected
QVERIFY(!parser.parse(QByteArrayLiteral("{ \"asset\": { \"version\": \"1.0\" } }"), QString(), &document));
QVERIFY(parser.errorMessage().contains(QStringLiteral("version")));
// Missing asset object
QVERIFY(!parser.parse(QByteArrayLiteral("{ }"), QString(), &document));
}
// Inputs a well-meaning exporter would never produce, but a hostile file
// can: each of these used to be able to reach out-of-bounds reads or
// writes, oversized allocations, or infinite recursion in consumers.
void tst_qssggltfparser::hostileInputValidation()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
// Negative buffer view byte offset (would address before the buffer)
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"uri\": \"data:,0123456789\", \"byteLength\": 10 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteOffset\": -1000000, \"byteLength\": 10 } ] }"),
QString(), &document));
// Buffer view byte stride beyond the specification maximum of 252
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"uri\": \"data:,0123456789\", \"byteLength\": 10 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteLength\": 10, \"byteStride\": 1000000000 } ] }"),
QString(), &document));
// Buffer view byte offset and length that are each positive but whose sum
// overflows to a negative value, which would otherwise read as fitting
// inside a ten-byte buffer
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"uri\": \"data:,0123456789\", \"byteLength\": 10 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteOffset\": 5000000000000000000,"
" \"byteLength\": 5000000000000000000 } ] }"),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("extends past")), qPrintable(parser.errorMessage()));
// Negative accessor byte offset and negative count
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"uri\": \"data:,0123456789\", \"byteLength\": 10 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteLength\": 10 } ],"
" \"accessors\": [ { \"bufferView\": 0, \"byteOffset\": -8, \"componentType\": 5126,"
" \"count\": 1, \"type\": \"SCALAR\" } ] }"),
QString(), &document));
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"accessors\": [ { \"componentType\": 5126, \"count\": -5, \"type\": \"SCALAR\" } ] }"),
QString(), &document));
// Accessor without a buffer view reads as zeros, so a huge count is an
// allocation bomb rather than a data reference
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"accessors\": [ { \"componentType\": 5126, \"count\": 4000000000, \"type\": \"VEC4\" } ] }"),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("unreasonably large")),
qPrintable(parser.errorMessage()));
// A count of 2^62 is exactly representable as a double, so it survives JSON
// parsing intact. Without an element cap, (count - 1) * stride + elementSize
// overflows to 0, the bounds check below it reads as satisfied, and a
// ten-line document yields an accessor claiming 2^62 elements.
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"uri\": \"data:,0123456789\", \"byteLength\": 10 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteLength\": 10 } ],"
" \"accessors\": [ { \"bufferView\": 0, \"componentType\": 5126,"
" \"count\": 4611686018427387904, \"type\": \"SCALAR\" } ] }"),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("unreasonably large")),
qPrintable(parser.errorMessage()));
// The same cap has to apply to the sparse count, which is multiplied by a
// component size while validating the sparse buffer views
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"uri\": \"data:,0123456789\", \"byteLength\": 10 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteLength\": 10 } ],"
" \"accessors\": [ { \"bufferView\": 0, \"componentType\": 5126, \"count\": 1,"
" \"type\": \"SCALAR\","
" \"sparse\": { \"count\": 4611686018427387904,"
" \"indices\": { \"bufferView\": 0, \"componentType\": 5123 },"
" \"values\": { \"bufferView\": 0 } } } ] }"),
QString(), &document));
// A near-2^63 offset only overflows a span of 1025 bytes or more, and a span
// that large has to fit its buffer view, hence the 2048-byte buffer
const auto withLargeBuffer = [](const QByteArray &accessor) {
return QByteArrayLiteral("{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"uri\": \"data:,")
+ QByteArray(2048, 'A')
+ QByteArrayLiteral("\", \"byteLength\": 2048 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteLength\": 2048 } ],"
" \"accessors\": [ ")
+ accessor + QByteArrayLiteral(" ] }");
};
// Accessor byte offset that overflows once its span is added
QVERIFY(!parser.parse(withLargeBuffer(QByteArrayLiteral(
"{ \"bufferView\": 0, \"byteOffset\": 9223372036854774784,"
" \"componentType\": 5126, \"count\": 300, \"type\": \"SCALAR\" }")),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("extends past")),
qPrintable(parser.errorMessage()));
// The same overflow in each of the two sparse byte offsets
QVERIFY(!parser.parse(withLargeBuffer(QByteArrayLiteral(
"{ \"componentType\": 5123, \"count\": 600, \"type\": \"SCALAR\","
" \"sparse\": { \"count\": 600,"
" \"indices\": { \"bufferView\": 0, \"componentType\": 5123,"
" \"byteOffset\": 9223372036854774784 },"
" \"values\": { \"bufferView\": 0 } } }")),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("sparse")), qPrintable(parser.errorMessage()));
QVERIFY(!parser.parse(withLargeBuffer(QByteArrayLiteral(
"{ \"componentType\": 5123, \"count\": 600, \"type\": \"SCALAR\","
" \"sparse\": { \"count\": 600,"
" \"indices\": { \"bufferView\": 0, \"componentType\": 5123 },"
" \"values\": { \"bufferView\": 0,"
" \"byteOffset\": 9223372036854774784 } } }")),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("sparse")), qPrintable(parser.errorMessage()));
// A material naming a texture that does not exist
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"materials\": [ { \"pbrMetallicRoughness\":"
" { \"baseColorTexture\": { \"index\": 3 } } } ] }"),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("invalid texture")),
qPrintable(parser.errorMessage()));
// A buffer URI is a relative reference; one that climbs out of the asset
// directory must not be resolved and loaded
QVERIFY(QSSGGltfResourceResolver::resolveFilePath(u"../../../etc/passwd",
QStringLiteral("/tmp/assets")).isEmpty());
QVERIFY(QSSGGltfResourceResolver::resolveFilePath(u"/etc/passwd",
QStringLiteral("/tmp/assets")).isEmpty());
QVERIFY(QSSGGltfResourceResolver::resolveFilePath(u":/secret.bin",
QStringLiteral("/tmp/assets")).isEmpty());
QCOMPARE(QSSGGltfResourceResolver::resolveFilePath(u"textures/wood.png",
QStringLiteral("/tmp/assets")),
QStringLiteral("/tmp/assets/textures/wood.png"));
// minVersion above what is implemented has to fail rather than load
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\", \"minVersion\": \"2.1\" } }"),
QString(), &document));
// Sparse indices extending past their buffer view
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"uri\": \"data:,0123456789\", \"byteLength\": 10 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteLength\": 10 } ],"
" \"accessors\": [ { \"componentType\": 5126, \"count\": 1000, \"type\": \"SCALAR\","
" \"sparse\": { \"count\": 1000,"
" \"indices\": { \"bufferView\": 0, \"componentType\": 5125 },"
" \"values\": { \"bufferView\": 0 } } } ] }"),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("sparse")), qPrintable(parser.errorMessage()));
// A node hierarchy cycle would recurse forever in consumers
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"nodes\": [ { \"children\": [1] }, { \"children\": [0] } ],"
" \"scenes\": [ { \"nodes\": [] } ], \"scene\": 0 }"),
QString(), &document));
// A node with two parents cannot be represented, and emitting its subtree
// twice is not an option either, so the second edge is dropped and the
// rest of the asset still loads. The first parent keeps the child.
QTest::ignoreMessage(QtWarningMsg, "Node 2 has more than one parent; ignoring the edge from node 1");
QVERIFY2(parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"nodes\": [ { \"children\": [2] }, { \"children\": [2] }, { } ],"
" \"scenes\": [ { \"nodes\": [0, 1] } ], \"scene\": 0 }"),
QString(), &document), qPrintable(parser.errorMessage()));
QCOMPARE(document.nodes.at(0).children, QList<int>({ 2 }));
QCOMPARE(document.nodes.at(1).children, QList<int>());
// The same node listed twice as a child of one parent
QTest::ignoreMessage(QtWarningMsg, "Node 1 has more than one parent; ignoring the edge from node 0");
QVERIFY2(parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"nodes\": [ { \"children\": [1, 1] }, { } ] }"),
QString(), &document), qPrintable(parser.errorMessage()));
QCOMPARE(document.nodes.at(0).children, QList<int>({ 1 }));
// Scene nodes must be unique root nodes, so a repeated entry, or one that
// is somebody's child, is dropped from the scene rather than failing it
QTest::ignoreMessage(QtWarningMsg, "Scene 0 references node 0 which is not a unique root node; ignoring it");
QVERIFY2(parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"nodes\": [ { }, { } ],"
" \"scenes\": [ { \"nodes\": [0, 0] } ], \"scene\": 0 }"),
QString(), &document), qPrintable(parser.errorMessage()));
QCOMPARE(document.scenes.at(0).nodes, QList<int>({ 0 }));
QTest::ignoreMessage(QtWarningMsg, "Scene 0 references node 1 which is not a unique root node; ignoring it");
QVERIFY2(parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"nodes\": [ { \"children\": [1] }, { } ],"
" \"scenes\": [ { \"nodes\": [0, 1] } ], \"scene\": 0 }"),
QString(), &document), qPrintable(parser.errorMessage()));
QCOMPARE(document.scenes.at(0).nodes, QList<int>({ 0 }));
// An absurdly deep hierarchy would exhaust the stack in recursive
// consumers; a moderately deep one must keep working
const auto chainOfNodes = [](int count) {
QByteArray json = QByteArrayLiteral("{ \"asset\": { \"version\": \"2.0\" }, \"nodes\": [");
for (int i = 0; i < count; ++i) {
if (i)
json += ',';
json += i + 1 < count ? QByteArray("{ \"children\": [" + QByteArray::number(i + 1) + "] }")
: QByteArray("{ }");
}
json += QByteArrayLiteral("], \"scenes\": [ { \"nodes\": [0] } ], \"scene\": 0 }");
return json;
};
QVERIFY2(parser.parse(chainOfNodes(512), QString(), &document), qPrintable(parser.errorMessage()));
QVERIFY(!parser.parse(chainOfNodes(100000), QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("deeper")), qPrintable(parser.errorMessage()));
}
void tst_qssggltfparser::nodeVisibilityAndWebp()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
// KHR_node_visibility: visible false parsed, absence defaults to true.
// KHR_xmp_json_ld: accepted even when required; metadata stays raw.
// EXT_texture_webp: alternate image source preferred over the fallback.
QVERIFY2(parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"extensionsUsed\": [ \"KHR_node_visibility\", \"EXT_texture_webp\", \"KHR_xmp_json_ld\" ],"
" \"extensionsRequired\": [ \"KHR_node_visibility\", \"KHR_xmp_json_ld\" ],"
" \"nodes\": [ { \"extensions\": { \"KHR_node_visibility\": { \"visible\": false } } }, { } ],"
" \"images\": [ { \"uri\": \"fallback.png\" }, { \"uri\": \"image.webp\" } ],"
" \"textures\": [ { \"source\": 0, \"extensions\": { \"EXT_texture_webp\": { \"source\": 1 } } },"
" { \"source\": 0 } ] }"),
QString(), &document),
qPrintable(parser.errorMessage()));
QCOMPARE(document.nodes.size(), 2);
QCOMPARE(document.nodes.at(0).visible, false);
QCOMPARE(document.nodes.at(1).visible, true);
QCOMPARE(document.textures.at(0).webpSource, 1);
QCOMPARE(document.textures.at(0).source, 0);
QCOMPARE(document.textures.at(1).webpSource, -1);
// An out-of-range EXT_texture_webp source is structurally invalid
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"images\": [ { \"uri\": \"fallback.png\" } ],"
" \"textures\": [ { \"source\": 0, \"extensions\": { \"EXT_texture_webp\": { \"source\": 7 } } } ] }"),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("invalid image")), qPrintable(parser.errorMessage()));
}
void tst_qssggltfparser::meshoptCompression()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
// Payloads created with meshopt_encodeVertexBuffer/encodeIndexBuffer
// (and meshopt_encodeFilterExp with 15-bit shared-vector mode for the
// filtered variant) from 4 vec3 positions and 6 quad indices
const QByteArray json = QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"extensionsUsed\": [ \"EXT_meshopt_compression\" ],"
" \"extensionsRequired\": [ \"EXT_meshopt_compression\" ],"
" \"buffers\": ["
" { \"uri\": \"data:application/octet-stream;base64,ofrq6gAAAP8AfwB+AAB/AAAAAH4AAAAAAAAAAAAAAAAA"
"AAAAAAAAAAABAQA=\", \"byteLength\": 44 },"
" { \"uri\": \"data:application/octet-stream;base64,4fAAAHaHVmd4qYZliWiYAWkAAA==\","
" \"byteLength\": 19 },"
" { \"byteLength\": 48, \"extensions\": { \"EXT_meshopt_compression\": { \"fallback\": true } } },"
" { \"uri\": \"data:application/octet-stream;base64,oe7u7gBAAD8AAgAAAABAAAACAAAAAAAgAAIAAAAAAAAA"
"AAAAAAAAAPIAAADyAAAA8gAAAA==\", \"byteLength\": 52 } ],"
" \"bufferViews\": ["
" { \"buffer\": 2, \"byteLength\": 48, \"byteStride\": 12, \"extensions\": {"
" \"EXT_meshopt_compression\": { \"buffer\": 0, \"byteLength\": 44, \"byteStride\": 12,"
" \"count\": 4, \"mode\": \"ATTRIBUTES\" } } },"
" { \"buffer\": 2, \"byteLength\": 24, \"extensions\": {"
" \"EXT_meshopt_compression\": { \"buffer\": 1, \"byteLength\": 19, \"byteStride\": 4,"
" \"count\": 6, \"mode\": \"TRIANGLES\" } } },"
" { \"buffer\": 2, \"byteLength\": 48, \"byteStride\": 12, \"extensions\": {"
" \"EXT_meshopt_compression\": { \"buffer\": 3, \"byteLength\": 52, \"byteStride\": 12,"
" \"count\": 4, \"mode\": \"ATTRIBUTES\","
" \"filter\": \"EXPONENTIAL\" } } } ],"
" \"accessors\": ["
" { \"bufferView\": 0, \"componentType\": 5126, \"count\": 4, \"type\": \"VEC3\" },"
" { \"bufferView\": 1, \"componentType\": 5125, \"count\": 6, \"type\": \"SCALAR\" },"
" { \"bufferView\": 2, \"componentType\": 5126, \"count\": 4, \"type\": \"VEC3\" } ] }");
QVERIFY2(parser.parse(json, QString(), &document), qPrintable(parser.errorMessage()));
const QList<float> expected = { 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.5f };
QCOMPARE(QSSGGltfAccessorReader::readAsFloats(document, 0), expected);
// The index codec preserves triangles and winding but may rotate the
// vertex order within a triangle: the source was 0,1,2 / 2,3,0
QCOMPARE(QSSGGltfAccessorReader::readIndices(document, 1), (QList<quint32> { 0, 1, 2, 0, 2, 3 }));
// 0.0, 1.0, and 0.5 survive the exponential filter exactly
QCOMPARE(QSSGGltfAccessorReader::readAsFloats(document, 2), expected);
// Corrupt compressed payload (truncated to 10 bytes)
QByteArray corrupt = json;
corrupt.replace("\"byteLength\": 44, \"byteStride\": 12", "\"byteLength\": 10, \"byteStride\": 12");
QVERIFY(!parser.parse(corrupt, QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("corrupt")), qPrintable(parser.errorMessage()));
// A regular buffer view cannot read from an unloaded fallback buffer
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"byteLength\": 48,"
" \"extensions\": { \"EXT_meshopt_compression\": { \"fallback\": true } } } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteLength\": 48 } ] }"),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("fallback")), qPrintable(parser.errorMessage()));
// Hostile decoded sizes and invalid mode/stride combinations
QByteArray bomb = json;
bomb.replace("\"count\": 4, \"mode\": \"ATTRIBUTES\" }", "\"count\": 400000000, \"mode\": \"ATTRIBUTES\" }");
QVERIFY(!parser.parse(bomb, QString(), &document));
// A count of 2^62 is exactly representable as a double, so it survives JSON
// parsing; multiplied by a valid stride of 12 the qint64 product wraps, and
// an unbounded check would read as satisfied and leave the decoder writing
// into a destination allocated from the wrapped size.
QByteArray wrap = json;
wrap.replace("\"count\": 4, \"mode\": \"ATTRIBUTES\" }",
"\"count\": 4611686018427387904, \"mode\": \"ATTRIBUTES\" }");
QVERIFY(!parser.parse(wrap, QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("unreasonable")), qPrintable(parser.errorMessage()));
// Compressed byte offset and length that are each positive but whose sum
// wraps negative, which would otherwise read as inside the source buffer
QByteArray offsetWrap = json;
offsetWrap.replace("\"buffer\": 0, \"byteLength\": 44",
"\"buffer\": 0, \"byteOffset\": 5000000000000000000, \"byteLength\": 5000000000000000000");
QVERIFY(!parser.parse(offsetWrap, QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("outside buffer")), qPrintable(parser.errorMessage()));
// Without a valid stride the size check must still reject a count that
// cannot be converted to a 64-bit integer
QByteArray hugeCountNoStride = json;
hugeCountNoStride.replace("\"byteLength\": 44, \"byteStride\": 12,", "\"byteLength\": 44,");
hugeCountNoStride.replace("\"count\": 4, \"mode\": \"ATTRIBUTES\" }", "\"count\": 1e300, \"mode\": \"ATTRIBUTES\" }");
QVERIFY(!parser.parse(hugeCountNoStride, QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("unreasonable")), qPrintable(parser.errorMessage()));
// A byte offset too large for a 64-bit integer must be rejected rather
// than converted, which would be undefined
QByteArray hugeOffset = json;
hugeOffset.replace("\"buffer\": 0, \"byteLength\": 44", "\"buffer\": 0, \"byteOffset\": 1e30, \"byteLength\": 44");
QVERIFY(!parser.parse(hugeOffset, QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("outside buffer")), qPrintable(parser.errorMessage()));
// Views decoding the same compressed range share one decoded buffer, so
// aliasing cannot multiply the memory a small file demands
QByteArray aliased = json;
aliased.replace("\"filter\": \"EXPONENTIAL\" } } } ],",
"\"filter\": \"EXPONENTIAL\" } } },"
" { \"buffer\": 2, \"byteLength\": 48, \"byteStride\": 12, \"extensions\": {"
" \"EXT_meshopt_compression\": { \"buffer\": 0, \"byteLength\": 44, \"byteStride\": 12,"
" \"count\": 4, \"mode\": \"ATTRIBUTES\" } } } ],");
aliased.replace("\"count\": 4, \"type\": \"VEC3\" } ] }",
"\"count\": 4, \"type\": \"VEC3\" },"
" { \"bufferView\": 3, \"componentType\": 5126, \"count\": 4, \"type\": \"VEC3\" } ] }");
QVERIFY2(parser.parse(aliased, QString(), &document), qPrintable(parser.errorMessage()));
QCOMPARE(document.bufferViews.size(), 4);
QCOMPARE(document.bufferViews.at(3).buffer, document.bufferViews.at(0).buffer);
QCOMPARE(document.buffers.size(), 4 + 3);
QCOMPARE(QSSGGltfAccessorReader::readAsFloats(document, 3), expected);
QByteArray badMode = json;
badMode.replace("\"mode\": \"TRIANGLES\"", "\"mode\": \"LINES\"");
QVERIFY(!parser.parse(badMode, QString(), &document));
QByteArray badStride = json;
badStride.replace("\"byteLength\": 19, \"byteStride\": 4", "\"byteLength\": 19, \"byteStride\": 8");
QVERIFY(!parser.parse(badStride, QString(), &document));
// In a GLB the compressed data goes in the BIN chunk, and the extension
// requires the fallback placeholder to sit at index 1 or above "to avoid
// conflicts with GLB binary buffer". Check that layout end to end, since
// only the first buffer may claim the BIN chunk.
const QByteArray compressed = QByteArray::fromBase64(
"ofrq6gAAAP8AfwB+AAB/AAAAAH4AAAAAAAAAAAAAAAAAAAAAAAAAAAABAQA=");
QCOMPARE(compressed.size(), 44);
const QByteArray glbJson = QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"extensionsUsed\": [ \"EXT_meshopt_compression\" ],"
" \"extensionsRequired\": [ \"EXT_meshopt_compression\" ],"
" \"buffers\": ["
" { \"byteLength\": 44 },"
" { \"byteLength\": 48, \"extensions\": { \"EXT_meshopt_compression\": { \"fallback\": true } } } ],"
" \"bufferViews\": ["
" { \"buffer\": 1, \"byteLength\": 48, \"byteStride\": 12, \"extensions\": {"
" \"EXT_meshopt_compression\": { \"buffer\": 0, \"byteLength\": 44, \"byteStride\": 12,"
" \"count\": 4, \"mode\": \"ATTRIBUTES\" } } } ],"
" \"accessors\": ["
" { \"bufferView\": 0, \"componentType\": 5126, \"count\": 4, \"type\": \"VEC3\" } ] }");
QVERIFY2(parser.parse(makeGlb(glbJson, compressed), QString(), &document),
qPrintable(parser.errorMessage()));
QCOMPARE(QSSGGltfAccessorReader::readAsFloats(document, 0), expected);
// The reverse layout puts the uri-less fallback first, which leaves the
// compressed buffer wanting the BIN chunk from index 1. That is what the
// extension's index requirement exists to prevent, so it is rejected with a
// clear message rather than silently mis-read.
QByteArray glbSwapped = glbJson;
glbSwapped.replace("{ \"byteLength\": 44 },"
" { \"byteLength\": 48, \"extensions\": { \"EXT_meshopt_compression\": "
"{ \"fallback\": true } } } ]",
"{ \"byteLength\": 48, \"extensions\": { \"EXT_meshopt_compression\": "
"{ \"fallback\": true } } },"
" { \"byteLength\": 44 } ]");
glbSwapped.replace("\"buffer\": 1, \"byteLength\": 48, \"byteStride\": 12",
"\"buffer\": 0, \"byteLength\": 48, \"byteStride\": 12");
glbSwapped.replace("\"buffer\": 0, \"byteLength\": 44", "\"buffer\": 1, \"byteLength\": 44");
QVERIFY(!parser.parse(makeGlb(glbSwapped, compressed), QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("first buffer")), qPrintable(parser.errorMessage()));
}
void tst_qssggltfparser::meshGpuInstancing()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"extensionsUsed\": [ \"EXT_mesh_gpu_instancing\" ],"
" \"accessors\": ["
" { \"componentType\": 5126, \"count\": 3, \"type\": \"VEC3\" },"
" { \"componentType\": 5126, \"count\": 3, \"type\": \"VEC4\" } ],"
" \"nodes\": [ { \"extensions\": { \"EXT_mesh_gpu_instancing\": {"
" \"attributes\": { \"TRANSLATION\": 0, \"ROTATION\": 1, \"SCALE\": 0 } } } },"
" { } ] }"),
QString(), &document),
qPrintable(parser.errorMessage()));
QCOMPARE(document.nodes.at(0).hasInstancing, true);
QCOMPARE(document.nodes.at(0).instanceTranslation, 0);
QCOMPARE(document.nodes.at(0).instanceRotation, 1);
QCOMPARE(document.nodes.at(0).instanceScale, 0);
QCOMPARE(document.nodes.at(1).hasInstancing, false);
// Instance attributes referencing an invalid accessor are structural
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"nodes\": [ { \"extensions\": { \"EXT_mesh_gpu_instancing\": {"
" \"attributes\": { \"TRANSLATION\": 9 } } } } ] }"),
QString(), &document));
QVERIFY2(parser.errorMessage().contains(QStringLiteral("instance attribute")),
qPrintable(parser.errorMessage()));
}
void tst_qssggltfparser::materialVariants()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"extensionsUsed\": [ \"KHR_materials_variants\" ],"
" \"extensions\": { \"KHR_materials_variants\": {"
" \"variants\": [ { \"name\": \"Red\" }, { \"name\": \"Blue\" } ] } },"
" \"materials\": [ { \"name\": \"default\" }, { \"name\": \"red\" }, { \"name\": \"blue\" } ],"
" \"accessors\": [ { \"componentType\": 5126, \"count\": 3, \"type\": \"VEC3\" } ],"
" \"meshes\": [ { \"primitives\": [ {"
" \"attributes\": { \"POSITION\": 0 }, \"material\": 0,"
" \"extensions\": { \"KHR_materials_variants\": { \"mappings\": ["
" { \"material\": 1, \"variants\": [0] },"
" { \"material\": 2, \"variants\": [1] } ] } } } ] } ] }"),
QString(), &document),
qPrintable(parser.errorMessage()));
QCOMPARE(document.materialVariants, (QStringList { QStringLiteral("Red"), QStringLiteral("Blue") }));
const QSSGGltf::MeshPrimitive &primitive = document.meshes.at(0).primitives.at(0);
QCOMPARE(primitive.variantMappings.size(), 2);
QCOMPARE(primitive.effectiveMaterial(-1), 0); // default
QCOMPARE(primitive.effectiveMaterial(0), 1); // Red
QCOMPARE(primitive.effectiveMaterial(1), 2); // Blue
QCOMPARE(primitive.effectiveMaterial(5), 0); // unmapped variant -> default
// Mappings referencing invalid materials or variants are structural
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"materials\": [ { } ],"
" \"accessors\": [ { \"componentType\": 5126, \"count\": 3, \"type\": \"VEC3\" } ],"
" \"meshes\": [ { \"primitives\": [ {"
" \"attributes\": { \"POSITION\": 0 },"
" \"extensions\": { \"KHR_materials_variants\": { \"mappings\": ["
" { \"material\": 7, \"variants\": [0] } ] } } } ] } ] }"),
QString(), &document));
QVERIFY(!parser.parse(QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"materials\": [ { } ],"
" \"accessors\": [ { \"componentType\": 5126, \"count\": 3, \"type\": \"VEC3\" } ],"
" \"meshes\": [ { \"primitives\": [ {"
" \"attributes\": { \"POSITION\": 0 },"
" \"extensions\": { \"KHR_materials_variants\": { \"mappings\": ["
" { \"material\": 0, \"variants\": [3] } ] } } } ] } ] }"),
QString(), &document));
}
void tst_qssggltfparser::readAccessorData()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parseFile(testFile(QStringLiteral("triangle.gltf")), &document),
qPrintable(parser.errorMessage()));
const QList<float> positions = QSSGGltfAccessorReader::readAsFloats(document, 0);
QCOMPARE(positions.size(), 9);
QCOMPARE(positions.at(3), 1.0f); // second vertex x
QCOMPARE(positions.at(7), 1.0f); // third vertex y
const QList<quint32> indices = QSSGGltfAccessorReader::readIndices(document, 1);
QCOMPARE(indices, QList<quint32>({ 0, 1, 2 }));
// Out-of-range accessor indices are safe
QVERIFY(QSSGGltfAccessorReader::readAsFloats(document, -1).isEmpty());
QVERIFY(QSSGGltfAccessorReader::readAsFloats(document, 7).isEmpty());
}
void tst_qssggltfparser::readSparseAccessor()
{
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parseFile(testFile(QStringLiteral("sparse.gltf")), &document),
qPrintable(parser.errorMessage()));
// The base data is all zeros; sparse substitution replaces elements 2 and 4
const QList<float> positions = QSSGGltfAccessorReader::readAsFloats(document, 0);
QCOMPARE(positions.size(), 18);
QCOMPARE(positions.mid(0, 3), QList<float>({ 0, 0, 0 }));
QCOMPARE(positions.mid(6, 3), QList<float>({ 1, 2, 3 }));
QCOMPARE(positions.mid(9, 3), QList<float>({ 0, 0, 0 }));
QCOMPARE(positions.mid(12, 3), QList<float>({ 4, 5, 6 }));
}
void tst_qssggltfparser::readInterleavedAccessor()
{
// Two vec3 attributes interleaved in one buffer view with byteStride 24:
// element i of the first attribute at offset i*24, of the second at i*24+12
QByteArray bin;
const float data[] = { 1, 2, 3, 10, 20, 30, 4, 5, 6, 40, 50, 60 };
bin.append(reinterpret_cast<const char *>(data), sizeof(data));
const QByteArray json = QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"byteLength\": 48 } ],"
" \"bufferViews\": [ { \"buffer\": 0, \"byteLength\": 48, \"byteStride\": 24 } ],"
" \"accessors\": ["
" { \"bufferView\": 0, \"byteOffset\": 0, \"componentType\": 5126, \"count\": 2, \"type\": \"VEC3\" },"
" { \"bufferView\": 0, \"byteOffset\": 12, \"componentType\": 5126, \"count\": 2, \"type\": \"VEC3\" } ] }");
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parse(makeGlb(json, bin), QString(), &document), qPrintable(parser.errorMessage()));
QCOMPARE(QSSGGltfAccessorReader::readAsFloats(document, 0), QList<float>({ 1, 2, 3, 4, 5, 6 }));
QCOMPARE(QSSGGltfAccessorReader::readAsFloats(document, 1), QList<float>({ 10, 20, 30, 40, 50, 60 }));
}
void tst_qssggltfparser::readNormalizedAccessor()
{
// Normalized u8 and s16 component data (as KHR_mesh_quantization produces)
QByteArray bin;
const quint8 u8data[] = { 0, 51, 255, 128 };
bin.append(reinterpret_cast<const char *>(u8data), sizeof(u8data));
const qint16 s16data[] = { -32768, -16384, 16384, 32767 };
bin.append(reinterpret_cast<const char *>(s16data), sizeof(s16data));
const QByteArray json = QByteArrayLiteral(
"{ \"asset\": { \"version\": \"2.0\" },"
" \"buffers\": [ { \"byteLength\": 12 } ],"
" \"bufferViews\": ["
" { \"buffer\": 0, \"byteOffset\": 0, \"byteLength\": 4 },"
" { \"buffer\": 0, \"byteOffset\": 4, \"byteLength\": 8 } ],"
" \"accessors\": ["
" { \"bufferView\": 0, \"componentType\": 5121, \"count\": 1, \"type\": \"VEC4\", \"normalized\": true },"
" { \"bufferView\": 1, \"componentType\": 5122, \"count\": 1, \"type\": \"VEC4\", \"normalized\": true },"
" { \"bufferView\": 0, \"componentType\": 5121, \"count\": 1, \"type\": \"VEC4\" } ] }");
QSSGGltfParser parser;
QSSGGltfDocument document;
QVERIFY2(parser.parse(makeGlb(json, bin), QString(), &document), qPrintable(parser.errorMessage()));
const QList<float> u8normalized = QSSGGltfAccessorReader::readAsFloats(document, 0);
QCOMPARE(u8normalized.at(0), 0.0f);
QCOMPARE(u8normalized.at(1), 51.0f / 255.0f);
QCOMPARE(u8normalized.at(2), 1.0f);
const QList<float> s16normalized = QSSGGltfAccessorReader::readAsFloats(document, 1);
QCOMPARE(s16normalized.at(0), -1.0f); // clamped per spec: max(c/32767, -1)
QCOMPARE(s16normalized.at(3), 1.0f);
// Non-normalized integers are cast, not scaled
const QList<float> u8plain = QSSGGltfAccessorReader::readAsFloats(document, 2);
QCOMPARE(u8plain.at(1), 51.0f);
QCOMPARE(u8plain.at(2), 255.0f);
}
QTEST_APPLESS_MAIN(tst_qssggltfparser)
#include "tst_qssggltfparser.moc"