1	// Copyright (C) 2014 Klaralvdalens Datakonsult AB (KDAB).
2	// Copyright (C) 2016 The Qt Company Ltd and/or its subsidiary(-ies).
3	// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
4
5	#include "gltfimporter.h"
6
7	#include <QtCore/qdir.h>
8	#include <QtCore/qfileinfo.h>
9	#include <QtCore/qjsonarray.h>
10	#include <QtCore/qjsonobject.h>
11	#include <QtCore/qmath.h>
12
13	#include <QtGui/qquaternion.h>
14	#include <QtGui/qvector2d.h>
15
16	#include <Qt3DCore/qentity.h>
17	#include <Qt3DCore/qtransform.h>
18	#include <Qt3DCore/qgeometry.h>
19
20	#include <Qt3DRender/qcameralens.h>
21	#include <Qt3DRender/qcamera.h>
22	#include <Qt3DRender/qalphacoverage.h>
23	#include <Qt3DRender/qalphatest.h>
24	#include <Qt3DRender/qblendequation.h>
25	#include <Qt3DRender/qblendequationarguments.h>
26	#include <Qt3DRender/qclipplane.h>
27	#include <Qt3DRender/qcolormask.h>
28	#include <Qt3DRender/qcullface.h>
29	#include <Qt3DRender/qdithering.h>
30	#include <Qt3DRender/qmultisampleantialiasing.h>
31	#include <Qt3DRender/qpointsize.h>
32	#include <Qt3DRender/qnodepthmask.h>
33	#include <Qt3DRender/qdepthrange.h>
34	#include <Qt3DRender/qdepthtest.h>
35	#include <Qt3DRender/qseamlesscubemap.h>
36	#include <Qt3DRender/qstencilmask.h>
37	#include <Qt3DRender/qstenciloperation.h>
38	#include <Qt3DRender/qstenciloperationarguments.h>
39	#include <Qt3DRender/qstenciltest.h>
40	#include <Qt3DRender/qstenciltestarguments.h>
41	#include <Qt3DRender/qeffect.h>
42	#include <Qt3DRender/qfrontface.h>
43	#include <Qt3DRender/qgeometryrenderer.h>
44	#include <Qt3DRender/qmaterial.h>
45	#include <Qt3DRender/qgraphicsapifilter.h>
46	#include <Qt3DRender/qparameter.h>
47	#include <Qt3DRender/qpolygonoffset.h>
48	#include <Qt3DRender/qrenderstate.h>
49	#include <Qt3DRender/qscissortest.h>
50	#include <Qt3DRender/qshaderprogram.h>
51	#include <Qt3DRender/qtechnique.h>
52	#include <Qt3DRender/qtexture.h>
53	#include <Qt3DRender/qtextureimagedatagenerator.h>
54	#include <Qt3DRender/qdirectionallight.h>
55	#include <Qt3DRender/qspotlight.h>
56	#include <Qt3DRender/qpointlight.h>
57
58	#include <Qt3DExtras/qphongmaterial.h>
59	#include <Qt3DExtras/qphongalphamaterial.h>
60	#include <Qt3DExtras/qdiffusemapmaterial.h>
61	#include <Qt3DExtras/qdiffusespecularmapmaterial.h>
62	#include <Qt3DExtras/qnormaldiffusemapmaterial.h>
63	#include <Qt3DExtras/qnormaldiffusemapalphamaterial.h>
64	#include <Qt3DExtras/qnormaldiffusespecularmapmaterial.h>
65	#include <Qt3DExtras/qgoochmaterial.h>
66	#include <Qt3DExtras/qpervertexcolormaterial.h>
67	#include <Qt3DExtras/qmetalroughmaterial.h>
68	#include <Qt3DExtras/qconemesh.h>
69	#include <Qt3DExtras/qcuboidmesh.h>
70	#include <Qt3DExtras/qcylindermesh.h>
71	#include <Qt3DExtras/qplanemesh.h>
72	#include <Qt3DExtras/qspheremesh.h>
73	#include <Qt3DExtras/qtorusmesh.h>
74
75	#include <private/qurlhelper_p.h>
76	#include <private/qloadgltf_p.h>
77
78	/**
79	* glTF 2.0 conformance report
80	*
81	* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0
82	* Samples: https://github.com/KhronosGroup/glTF-Sample-Models/tree/master/2.0
83	*
84	* Most of the reference samples are rendered correctly, with the following exceptions:
85	*
86	* 'extensions' and 'extras' are ignored everywhere except in nodes.
87	*
88	* asset
89	* generator, copyright, minVersion: not parsed
90	* accessors
91	* min, max, normalized, sparse: not parsed
92	* animations
93	* the whole object is not parsed
94	* buffers
95	* all parsed
96	* bufferViews
97	* all parsed
98	* cameras
99	* all parsed
100	* images
101	* mimeType, bufferView, name: not parsed
102	* materials
103	* emissiveTexture, emissiveFactor: not parsed
104	* alphaMode, alphaCutoff, doubleSided: not parsed
105	* texCoord, strength: not parsed
106	* meshes
107	* weights: not parsed
108	* nodes
109	* skin, weights: not parsed
110	* samplers
111	* all parsed
112	* scenes
113	* all parsed
114	* textures
115	* all parsed
116	*/
117
118	#ifndef qUtf16PrintableImpl // -Impl is a Qt 5.8 feature
119	# define qUtf16PrintableImpl(string) \
120	static_cast<const wchar_t*>(static_cast<const void*>(string.utf16()))
121	#endif
122
123	#define KEY_ASSET QLatin1String("asset")
124	#define KEY_VERSION QLatin1String("version")
125	#define KEY_CAMERA QLatin1String("camera")
126	#define KEY_CAMERAS QLatin1String("cameras")
127	#define KEY_SCENES QLatin1String("scenes")
128	#define KEY_NODES QLatin1String("nodes")
129	#define KEY_MESHES QLatin1String("meshes")
130	#define KEY_CHILDREN QLatin1String("children")
131	#define KEY_MESH QLatin1String("mesh")
132	#define KEY_MATRIX QLatin1String("matrix")
133	#define KEY_ROTATION QLatin1String("rotation")
134	#define KEY_SCALE QLatin1String("scale")
135	#define KEY_TRANSLATION QLatin1String("translation")
136	#define KEY_TYPE QLatin1String("type")
137	#define KEY_PERSPECTIVE QLatin1String("perspective")
138	#define KEY_ORTHOGRAPHIC QLatin1String("orthographic")
139	#define KEY_NAME QLatin1String("name")
140	#define KEY_COUNT QLatin1String("count")
141	#define KEY_YFOV QLatin1String("yfov")
142	#define KEY_ZNEAR QLatin1String("znear")
143	#define KEY_ZFAR QLatin1String("zfar")
144	#define KEY_XMAG QLatin1String("xmag")
145	#define KEY_YMAG QLatin1String("ymag")
146	#define KEY_MATERIALS QLatin1String("materials")
147	#define KEY_EXTENSIONS QLatin1String("extensions")
148	#define KEY_COMMON_MAT QLatin1String("KHR_materials_common")
149	#define KEY_TECHNIQUE QLatin1String("technique")
150	#define KEY_VALUES QLatin1String("values")
151	#define KEY_BUFFERS QLatin1String("buffers")
152	#define KEY_SHADERS QLatin1String("shaders")
153	#define KEY_PROGRAMS QLatin1String("programs")
154	#define KEY_PROGRAM QLatin1String("program")
155	#define KEY_TECHNIQUES QLatin1String("techniques")
156	#define KEY_ACCESSORS QLatin1String("accessors")
157	#define KEY_IMAGES QLatin1String("images")
158	#define KEY_TEXTURES QLatin1String("textures")
159	#define KEY_SCENE QLatin1String("scene")
160	#define KEY_BUFFER QLatin1String("buffer")
161	#define KEY_TARGET QLatin1String("target")
162	#define KEY_BYTE_OFFSET QLatin1String("byteOffset")
163	#define KEY_BYTE_LENGTH QLatin1String("byteLength")
164	#define KEY_BYTE_STRIDE QLatin1String("byteStride")
165	#define KEY_PRIMITIVES QLatin1String("primitives")
166	#define KEY_MODE QLatin1String("mode")
167	#define KEY_MATERIAL QLatin1String("material")
168	#define KEY_ATTRIBUTES QLatin1String("attributes")
169	#define KEY_INDICES QLatin1String("indices")
170	#define KEY_URI QLatin1String("uri")
171	#define KEY_FORMAT QLatin1String("format")
172	#define KEY_PASSES QLatin1String("passes")
173	#define KEY_SOURCE QLatin1String("source")
174	#define KEY_SAMPLER QLatin1String("sampler")
175	#define KEY_SAMPLERS QLatin1String("samplers")
176	#define KEY_SEMANTIC QLatin1String("semantic")
177	#define KEY_STATES QLatin1String("states")
178	#define KEY_UNIFORMS QLatin1String("uniforms")
179	#define KEY_PARAMETERS QLatin1String("parameters")
180	#define KEY_WRAP_S QLatin1String("wrapS")
181	#define KEY_MIN_FILTER QLatin1String("minFilter")
182	#define KEY_MAG_FILTER QLatin1String("magFilter")
183	#define KEY_LIGHT QLatin1String("light")
184	#define KEY_LIGHTS QLatin1String("lights")
185	#define KEY_POINT_LIGHT QLatin1String("point")
186	#define KEY_DIRECTIONAL_LIGHT QLatin1String("directional")
187	#define KEY_SPOT_LIGHT QLatin1String("spot")
188	#define KEY_AMBIENT_LIGHT QLatin1String("ambient")
189	#define KEY_COLOR QLatin1String("color")
190	#define KEY_FALLOFF_ANGLE QLatin1String("falloffAngle")
191	#define KEY_DIRECTION QLatin1String("direction")
192	#define KEY_CONST_ATTENUATION QLatin1String("constantAttenuation")
193	#define KEY_LINEAR_ATTENUATION QLatin1String("linearAttenuation")
194	#define KEY_QUAD_ATTENUATION QLatin1String("quadraticAttenuation")
195	#define KEY_INTENSITY QLatin1String("intensity")
196	#define KEY_PBR_METAL_ROUGH QLatin1String("pbrMetallicRoughness")
197	#define KEY_BASE_COLOR QLatin1String("baseColorFactor")
198	#define KEY_BASE_COLOR_TEX QLatin1String("baseColorTexture")
199	#define KEY_METAL_FACTOR QLatin1String("metallicFactor")
200	#define KEY_METAL_ROUGH_TEX QLatin1String("metallicRoughnessTexture")
201	#define KEY_ROUGH_FACTOR QLatin1String("roughnessFactor")
202	#define KEY_NORMAL_TEX QLatin1String("normalTexture")
203	#define KEY_OCCLUSION_TEX QLatin1String("occlusionTexture")
204	#define KEY_INDEX QLatin1String("index")
205
206	#define KEY_INSTANCE_TECHNIQUE QLatin1String("instanceTechnique")
207	#define KEY_INSTANCE_PROGRAM QLatin1String("instanceProgram")
208	#define KEY_BUFFER_VIEWS QLatin1String("bufferViews")
209	#define KEY_BUFFER_VIEW QLatin1String("bufferView")
210	#define KEY_VERTEX_SHADER QLatin1String("vertexShader")
211	#define KEY_FRAGMENT_SHADER QLatin1String("fragmentShader")
212	#define KEY_TESS_CTRL_SHADER QLatin1String("tessCtrlShader")
213	#define KEY_TESS_EVAL_SHADER QLatin1String("tessEvalShader")
214	#define KEY_GEOMETRY_SHADER QLatin1String("geometryShader")
215	#define KEY_COMPUTE_SHADER QLatin1String("computeShader")
216	#define KEY_INTERNAL_FORMAT QLatin1String("internalFormat")
217	#define KEY_COMPONENT_TYPE QLatin1String("componentType")
218	#define KEY_ASPECT_RATIO QLatin1String("aspect_ratio")
219	#define KEY_VALUE QLatin1String("value")
220	#define KEY_ENABLE QLatin1String("enable")
221	#define KEY_FUNCTIONS QLatin1String("functions")
222	#define KEY_BLEND_EQUATION QLatin1String("blendEquationSeparate")
223	#define KEY_BLEND_FUNCTION QLatin1String("blendFuncSeparate")
224	#define KEY_TECHNIQUE_CORE QLatin1String("techniqueCore")
225	#define KEY_TECHNIQUE_GL2 QLatin1String("techniqueGL2")
226	#define KEY_GABIFILTER QLatin1String("gapifilter")
227	#define KEY_API QLatin1String("api")
228	#define KEY_MAJORVERSION QLatin1String("majorVersion")
229	#define KEY_MINORVERSION QLatin1String("minorVersion")
230	#define KEY_PROFILE QLatin1String("profile")
231	#define KEY_VENDOR QLatin1String("vendor")
232	#define KEY_FILTERKEYS QLatin1String("filterkeys")
233	#define KEY_RENDERPASSES QLatin1String("renderpasses")
234	#define KEY_EFFECT QLatin1String("effect")
235	#define KEY_EFFECTS QLatin1String("effects")
236	#define KEY_PROPERTIES QLatin1String("properties")
237	#define KEY_POSITION QLatin1String("position")
238	#define KEY_UPVECTOR QLatin1String("upVector")
239	#define KEY_VIEW_CENTER QLatin1String("viewCenter")
240
241	QT_BEGIN_NAMESPACE
242
243
244	namespace {
245
246	inline QVector3D jsonArrToVec3(const QJsonArray &array)
247	{
248	return QVector3D(array[0].toDouble(), array[1].toDouble(), array[2].toDouble());
249	}
250
251	inline QVector4D jsonArrToVec4(const QJsonArray &array)
252	{
253	return QVector4D(array[0].toDouble(), array[1].toDouble(),
254	array[2].toDouble(), array[3].toDouble());
255	}
256
257	inline QVariant jsonArrToColorVariant(const QJsonArray &array)
258	{
259	return QVariant(QColor::fromRgbF(r: array[0].toDouble(), g: array[1].toDouble(),
260	b: array[2].toDouble(), a: array[3].toDouble()));
261	}
262
263	inline QColor vec4ToQColor(const QVariant &vec4Var)
264	{
265	const QVector4D v = vec4Var.value<QVector4D>();
266	return QColor::fromRgbF(r: v.x(), g: v.y(), b: v.z());
267	}
268
269	inline QVariant vec4ToColorVariant(const QVariant &vec4Var)
270	{
271	return QVariant(vec4ToQColor(vec4Var));
272	}
273
274	Qt3DRender::QFilterKey *buildFilterKey(const QString &key, const QJsonValue &val)
275	{
276	Qt3DRender::QFilterKey *fk = new Qt3DRender::QFilterKey;
277	fk->setName(key);
278	if (val.isString())
279	fk->setValue(val.toString());
280	else
281	fk->setValue(val.toInt());
282	return fk;
283	}
284
285	} // namespace
286
287	namespace Qt3DRender {
288
289	using namespace Qt3DCore;
290	using namespace Qt3DExtras;
291
292	Q_LOGGING_CATEGORY(GLTFImporterLog, "Qt3D.GLTFImport", QtWarningMsg);
293
294	class GLTFRawTextureImage : public QAbstractTextureImage
295	{
296	Q_OBJECT
297	public:
298	explicit GLTFRawTextureImage(QNode *parent = nullptr);
299
300	QTextureImageDataGeneratorPtr dataGenerator() const final;
301
302	void setImage(const QImage &image);
303
304	private:
305	QImage m_image;
306
307	class GLTFRawTextureImageFunctor : public QTextureImageDataGenerator
308	{
309	public:
310	explicit GLTFRawTextureImageFunctor(const QImage &image);
311
312	QTextureImageDataPtr operator()() final;
313	bool operator ==(const QTextureImageDataGenerator &other) const final;
314
315	QT3D_FUNCTOR(GLTFRawTextureImageFunctor)
316	private:
317	QImage m_image;
318	};
319	};
320
321	GLTFImporter::GLTFImporter()
322	: QSceneImporter()
323	, m_parseDone(false)
324	, m_majorVersion(1)
325	, m_minorVersion(0)
326	{
327	}
328
329	GLTFImporter::~GLTFImporter()
330	{
331
332	}
333
334	/*!
335	\class Qt3DRender::GLTFImporter
336	\inmodule Qt3DRender
337	\internal
338	\brief Handles importing of gltf files.
339	*/
340	/*!
341	Set the base \a path for importing scenes.
342	*/
343	void GLTFImporter::setBasePath(const QString& path)
344	{
345	m_basePath = path;
346	}
347
348	/*!
349	Set a \a json document as the file used for importing a scene.
350	Returns true if the operation is successful.
351	*/
352	bool GLTFImporter::setJSON(const QJsonDocument &json)
353	{
354	if (!json.isObject()) {
355	return false;
356	}
357
358	m_json = json;
359	m_parseDone = false;
360
361	return true;
362	}
363
364	/*!
365	* Sets the path based on parameter \a source. The path is
366	* used by the parser to load the scene file.
367	* If the file is valid, parsing is automatically triggered.
368	*/
369	void GLTFImporter::setSource(const QUrl &source)
370	{
371	const QString path = QUrlHelper::urlToLocalFileOrQrc(url: source);
372	QFile f(path);
373	if (Q_UNLIKELY(!f.open(QIODevice::ReadOnly))) {
374	qCWarning(GLTFImporterLog, "failed to open: %ls: %ls", qUtf16PrintableImpl(path),
375	qUtf16PrintableImpl(f.errorString()));
376	return;
377	}
378
379	if (Q_UNLIKELY(!setJSON(qLoadGLTF(f.readAll())))) {
380	qCWarning(GLTFImporterLog, "not a JSON document");
381	return;
382	}
383
384	setBasePath(QFileInfo(path).dir().absolutePath());
385	}
386
387	/*!
388	* Sets the \a basePath used by the parser to load the scene file.
389	* If the file derived from \a data is valid, parsing is automatically
390	* triggered.
391	*/
392	void GLTFImporter::setData(const QByteArray& data, const QString &basePath)
393	{
394	if (Q_UNLIKELY(!setJSON(qLoadGLTF(data)))) {
395	qCWarning(GLTFImporterLog, "not a JSON document");
396	return;
397	}
398
399	setBasePath(basePath);
400	}
401
402	/*!
403	* Returns true if the \a extensions are supported by the
404	* GLTF parser.
405	*/
406	bool GLTFImporter::areFileTypesSupported(const QStringList &extensions) const
407	{
408	return GLTFImporter::isGLTFSupported(extensions);
409	}
410
411	/*!
412	Imports the node specified in \a id from the GLTF file.
413	*/
414	Qt3DCore::QEntity* GLTFImporter::node(const QString &id)
415	{
416	QJsonValue jsonVal;
417
418	if (m_majorVersion > 1) {
419	const QJsonArray nodes = m_json.object().value(KEY_NODES).toArray();
420	if (Q_UNLIKELY(id.toInt() >= nodes.count())) {
421	qCWarning(GLTFImporterLog, "unknown node %ls in GLTF file %ls",
422	qUtf16PrintableImpl(id), qUtf16PrintableImpl(m_basePath));
423	return nullptr;
424	}
425	jsonVal = nodes[id.toInt()];
426	} else {
427	const QJsonObject nodes = m_json.object().value(KEY_NODES).toObject();
428	jsonVal = nodes.value(key: id);
429	if (Q_UNLIKELY(jsonVal.isUndefined())) {
430	qCWarning(GLTFImporterLog, "unknown node %ls in GLTF file %ls",
431	qUtf16PrintableImpl(id), qUtf16PrintableImpl(m_basePath));
432	return nullptr;
433	}
434	}
435
436	const QJsonObject jsonObj = jsonVal.toObject();
437	QEntity* result = nullptr;
438
439	// Qt3D has a limitation that a QEntity can only have 1 mesh and 1 material component
440	// So if the node has only 1 mesh, we only create 1 QEntity
441	// Otherwise if there are n meshes, there is 1 QEntity, with n children for each mesh/material combo
442	{
443	QList<QEntity *> entities;
444	const QJsonValue meshesValue = jsonObj.value(KEY_MESHES);
445
446	if (meshesValue.isUndefined()) {
447	const QJsonValue mesh = jsonObj.value(KEY_MESH);
448	if (!mesh.isUndefined()) {
449	const QString meshName = QString::number(mesh.toInt());
450	const auto geometryRenderers = std::as_const(t&: m_meshDict).equal_range(key: meshName);
451	for (auto it = geometryRenderers.first; it != geometryRenderers.second; ++it) {
452	QGeometryRenderer *geometryRenderer = it.value();
453	QEntity *entity = new QEntity;
454	entity->addComponent(comp: geometryRenderer);
455	QMaterial *mat = material(id: m_meshMaterialDict[geometryRenderer]);
456	if (mat)
457	entity->addComponent(comp: mat);
458	entities.append(t: entity);
459	}
460	}
461	} else {
462	const auto meshes = meshesValue.toArray();
463	for (const QJsonValue mesh : meshes) {
464	const QString meshName = mesh.toString();
465	const auto geometryRenderers = std::as_const(t&: m_meshDict).equal_range(key: meshName);
466	if (Q_UNLIKELY(geometryRenderers.first == geometryRenderers.second)) {
467	qCWarning(GLTFImporterLog, "node %ls references unknown mesh %ls",
468	qUtf16PrintableImpl(id), qUtf16PrintableImpl(meshName));
469	continue;
470	}
471
472	for (auto it = geometryRenderers.first; it != geometryRenderers.second; ++it) {
473	QGeometryRenderer *geometryRenderer = it.value();
474	QEntity *entity = new QEntity;
475	entity->addComponent(comp: geometryRenderer);
476	QMaterial *mat = material(id: m_meshMaterialDict[geometryRenderer]);
477	if (mat)
478	entity->addComponent(comp: mat);
479	entities.append(t: entity);
480	}
481	}
482	}
483
484	switch (entities.size()) {
485	case 0:
486	break;
487	case 1:
488	result = std::as_const(t&: entities).first();
489	break;
490	default:
491	result = new QEntity;
492	for (QEntity *entity : std::as_const(t&: entities))
493	entity->setParent(result);
494	}
495	}
496
497	const auto cameraVal = jsonObj.value(KEY_CAMERA);
498	const auto matrix = jsonObj.value(KEY_MATRIX);
499	const auto rotation = jsonObj.value(KEY_ROTATION);
500	const auto translation = jsonObj.value(KEY_TRANSLATION);
501	const auto scale = jsonObj.value(KEY_SCALE);
502	Qt3DCore::QTransform *trans = nullptr;
503	QCameraLens *cameraLens = nullptr;
504	QCamera *cameraEntity = nullptr;
505
506	// If the node contains no meshes, results will still be null here.
507	// If the node has camera and transform, promote it to QCamera, as that makes it more
508	// convenient to adjust the imported camera in the application.
509	if (result == nullptr) {
510	if (!cameraVal.isUndefined()
511	&& (!matrix.isUndefined() || !rotation.isUndefined() || !translation.isUndefined()
512	|| !scale.isUndefined())) {
513	cameraEntity = new QCamera;
514	trans = cameraEntity->transform();
515	cameraLens = cameraEntity->lens();
516	result = cameraEntity;
517	} else {
518	result = new QEntity;
519	}
520	}
521
522	// recursively retrieve children
523	const auto children = jsonObj.value(KEY_CHILDREN).toArray();
524	for (const QJsonValue c : children) {
525	QEntity* child = node(id: (m_majorVersion > 1) ? QString::number(c.toInt()) : c.toString());
526	if (!child)
527	continue;
528	child->setParent(result);
529	}
530
531	renameFromJson(json: jsonObj, object: result);
532
533	// Node Transforms
534	if (!matrix.isUndefined()) {
535	QMatrix4x4 m(Qt::Uninitialized);
536
537	QJsonArray matrixValues = matrix.toArray();
538	for (int i = 0; i < 16; ++i) {
539	double v = matrixValues.at(i).toDouble();
540	m(i % 4, i >> 2) = v;
541	}
542
543	if (!trans)
544	trans = new Qt3DCore::QTransform;
545	trans->setMatrix(m);
546	}
547
548	// Rotation quaternion
549	if (!rotation.isUndefined()) {
550	if (!trans)
551	trans = new Qt3DCore::QTransform;
552
553	QQuaternion quaternion(jsonArrToVec4(array: rotation.toArray()));
554	trans->setRotation(quaternion);
555	}
556
557	// Translation
558	if (!translation.isUndefined()) {
559	if (!trans)
560	trans = new Qt3DCore::QTransform;
561	trans->setTranslation(jsonArrToVec3(array: translation.toArray()));
562	}
563
564	// Scale
565	if (!scale.isUndefined()) {
566	if (!trans)
567	trans = new Qt3DCore::QTransform;
568	trans->setScale3D(jsonArrToVec3(array: scale.toArray()));
569	}
570
571	// Add the Transform component
572	if (trans != nullptr)
573	result->addComponent(comp: trans);
574
575	if (!cameraVal.isUndefined()) {
576	const bool newLens = cameraLens == nullptr;
577	if (newLens)
578	cameraLens = new QCameraLens;
579	const QString cameraID = (m_majorVersion > 1) ? QString::number(cameraVal.toInt()) : cameraVal.toString();
580	if (!fillCamera(lens&: *cameraLens, cameraEntity, id: cameraID)) {
581	qCWarning(GLTFImporterLog, "failed to build camera: %ls on node %ls",
582	qUtf16PrintableImpl(cameraID), qUtf16PrintableImpl(id));
583	} else if (newLens) {
584	result->addComponent(comp: cameraLens);
585	}
586	}
587
588	const auto extensionsVal = jsonObj.value(KEY_EXTENSIONS);
589	if (!extensionsVal.isUndefined()) {
590	const auto commonMat = extensionsVal.toObject().value(KEY_COMMON_MAT);
591	if (!commonMat.isUndefined()) {
592	const QJsonValue lightVal = commonMat.toObject().value(KEY_LIGHT);
593	const QString lightId = (m_majorVersion > 1) ? QString::number(lightVal.toInt()) : lightVal.toString();
594	QAbstractLight *lightComp = m_lights.value(key: lightId);
595	if (Q_UNLIKELY(!lightComp)) {
596	qCWarning(GLTFImporterLog, "failed to find light: %ls for node %ls",
597	qUtf16PrintableImpl(lightId), qUtf16PrintableImpl(id));
598	} else {
599	result->addComponent(comp: lightComp);
600	}
601	}
602	}
603
604	return result;
605	}
606
607	/*!
608	Imports the scene specified in parameter \a id.
609	*/
610	Qt3DCore::QEntity* GLTFImporter::scene(const QString &id)
611	{
612	parse();
613
614	QEntity* sceneEntity = nullptr;
615
616	if (m_majorVersion > 1) {
617	const QJsonArray scenes = m_json.object().value(KEY_SCENES).toArray();
618	const auto sceneVal = scenes.first();
619	if (Q_UNLIKELY(sceneVal.isUndefined())) {
620	if (Q_UNLIKELY(!id.isNull()))
621	qCWarning(GLTFImporterLog, "GLTF: no such scene %ls in file %ls",
622	qUtf16PrintableImpl(id), qUtf16PrintableImpl(m_basePath));
623	return defaultScene();
624	}
625	const QJsonObject sceneObj = sceneVal.toObject();
626	sceneEntity = new QEntity;
627	const auto nodes = sceneObj.value(KEY_NODES).toArray();
628	for (const QJsonValue n : nodes) {
629	QEntity* child = node(id: QString::number(n.toInt()));
630	if (!child)
631	continue;
632	child->setParent(sceneEntity);
633	}
634	} else {
635	const QJsonObject scenes = m_json.object().value(KEY_SCENES).toObject();
636	const auto sceneVal = scenes.value(key: id);
637	if (Q_UNLIKELY(sceneVal.isUndefined())) {
638	if (Q_UNLIKELY(!id.isNull()))
639	qCWarning(GLTFImporterLog, "GLTF: no such scene %ls in file %ls",
640	qUtf16PrintableImpl(id), qUtf16PrintableImpl(m_basePath));
641	return defaultScene();
642	}
643
644	const QJsonObject sceneObj = sceneVal.toObject();
645	sceneEntity = new QEntity;
646	const auto nodes = sceneObj.value(KEY_NODES).toArray();
647	for (const QJsonValue nnv : nodes) {
648	QString nodeName = nnv.toString();
649	QEntity* child = node(id: nodeName);
650	if (!child)
651	continue;
652	child->setParent(sceneEntity);
653	}
654	}
655
656	cleanup();
657
658	return sceneEntity;
659	}
660
661	GLTFImporter::BufferData::BufferData()
662	: length(0)
663	, data(nullptr)
664	{
665	}
666
667	GLTFImporter::BufferData::BufferData(const QJsonObject &json)
668	: length(json.value(KEY_BYTE_LENGTH).toInt()),
669	path(json.value(KEY_URI).toString()),
670	data(nullptr)
671	{
672	}
673
674	GLTFImporter::ParameterData::ParameterData() :
675	type(0)
676	{
677
678	}
679
680	GLTFImporter::ParameterData::ParameterData(const QJsonObject &json)
681	: semantic(json.value(KEY_SEMANTIC).toString()),
682	type(json.value(KEY_TYPE).toInt())
683	{
684	}
685
686	GLTFImporter::AccessorData::AccessorData()
687	: type(QAttribute::Float)
688	, dataSize(0)
689	, count(0)
690	, offset(0)
691	, stride(0)
692	{
693
694	}
695
696	GLTFImporter::AccessorData::AccessorData(const QJsonObject &json, int major, int minor)
697	: type(accessorTypeFromJSON(componentType: json.value(KEY_COMPONENT_TYPE).toInt())),
698	dataSize(accessorDataSizeFromJson(type: json.value(KEY_TYPE).toString())),
699	count(json.value(KEY_COUNT).toInt()),
700	offset(0),
701	stride(0)
702	{
703	Q_UNUSED(minor);
704
705	if (major > 1) {
706	bufferViewName = QString::number(json.value(KEY_BUFFER_VIEW).toInt());
707	} else {
708	bufferViewName = json.value(KEY_BUFFER_VIEW).toString();
709	}
710
711	const auto byteOffset = json.value(KEY_BYTE_OFFSET);
712	if (!byteOffset.isUndefined())
713	offset = byteOffset.toInt();
714	const auto byteStride = json.value(KEY_BYTE_STRIDE);
715	if (!byteStride.isUndefined())
716	stride = byteStride.toInt();
717	}
718
719	bool GLTFImporter::isGLTFSupported(const QStringList &extensions)
720	{
721	for (auto suffix: std::as_const(t: extensions)) {
722	suffix = suffix.toLower();
723	if (suffix == QLatin1String("json") || suffix == QLatin1String("gltf") || suffix == QLatin1String("qgltf"))
724	return true;
725	}
726	return false;
727	}
728
729	bool GLTFImporter::isEmbeddedResource(const QString &url)
730	{
731	return url.startsWith(s: "data:");
732	}
733
734	void GLTFImporter::renameFromJson(const QJsonObject &json, QObject * const object)
735	{
736	const auto name = json.value(KEY_NAME);
737	if (!name.isUndefined())
738	object->setObjectName(name.toString());
739	}
740
741	bool GLTFImporter::hasStandardUniformNameFromSemantic(const QString &semantic)
742	{
743	//Standard Uniforms
744	if (semantic.isEmpty())
745	return false;
746	switch (semantic.at(i: 0).toLatin1()) {
747	case 'L':
748	// return semantic == QLatin1String("LOCAL");
749	return false;
750	case 'M':
751	return semantic == QLatin1String("MODEL")
752	|| semantic == QLatin1String("MODELVIEW")
753	|| semantic == QLatin1String("MODELVIEWPROJECTION")
754	|| semantic == QLatin1String("MODELINVERSE")
755	|| semantic == QLatin1String("MODELVIEWPROJECTIONINVERSE")
756	|| semantic == QLatin1String("MODELINVERSETRANSPOSE")
757	|| semantic == QLatin1String("MODELVIEWINVERSETRANSPOSE");
758	case 'V':
759	return semantic == QLatin1String("VIEW")
760	|| semantic == QLatin1String("VIEWINVERSE")
761	|| semantic == QLatin1String("VIEWPORT");
762	case 'P':
763	return semantic == QLatin1String("PROJECTION")
764	|| semantic == QLatin1String("PROJECTIONINVERSE");
765	}
766	return false;
767	}
768
769	QString GLTFImporter::standardAttributeNameFromSemantic(const QString &semantic)
770	{
771	//Standard Attributes
772	if (semantic.startsWith(s: QLatin1String("POSITION")))
773	return QAttribute::defaultPositionAttributeName();
774	if (semantic.startsWith(s: QLatin1String("NORMAL")))
775	return QAttribute::defaultNormalAttributeName();
776	if (semantic.startsWith(s: QLatin1String("TEXCOORD")))
777	return QAttribute::defaultTextureCoordinateAttributeName();
778	if (semantic.startsWith(s: QLatin1String("COLOR")))
779	return QAttribute::defaultColorAttributeName();
780	if (semantic.startsWith(s: QLatin1String("TANGENT")))
781	return QAttribute::defaultTangentAttributeName();
782
783	// if (semantic.startsWith(QLatin1String("JOINT")));
784	// if (semantic.startsWith(QLatin1String("JOINTMATRIX")));
785	// if (semantic.startsWith(QLatin1String("WEIGHT")));
786
787	return QString();
788	}
789
790	QParameter *GLTFImporter::parameterFromTechnique(QTechnique *technique,
791	const QString &parameterName)
792	{
793	const QList<QParameter *> parameters = m_techniqueParameters.value(key: technique);
794	for (QParameter *parameter : parameters) {
795	if (parameter->name() == parameterName)
796	return parameter;
797	}
798
799	return nullptr;
800	}
801
802	Qt3DCore::QEntity* GLTFImporter::defaultScene()
803	{
804	if (Q_UNLIKELY(m_defaultScene.isEmpty())) {
805	qCWarning(GLTFImporterLog, "no default scene");
806	return nullptr;
807	}
808
809	return scene(id: m_defaultScene);
810	}
811
812	QMaterial *GLTFImporter::materialWithCustomShader(const QString &id, const QJsonObject &jsonObj)
813	{
814	QString effectName = jsonObj.value(KEY_EFFECT).toString();
815	if (effectName.isEmpty()) {
816	// GLTF custom shader material (with qgltf tool specific customizations)
817
818	// Default ES2 Technique
819	QString techniqueName = jsonObj.value(KEY_TECHNIQUE).toString();
820	const auto it = std::as_const(t&: m_techniques).find(key: techniqueName);
821	if (Q_UNLIKELY(it == m_techniques.cend())) {
822	qCWarning(GLTFImporterLog, "unknown technique %ls for material %ls in GLTF file %ls",
823	qUtf16PrintableImpl(techniqueName), qUtf16PrintableImpl(id), qUtf16PrintableImpl(m_basePath));
824	return nullptr;
825	}
826	QTechnique *technique = *it;
827	technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGLES);
828	technique->graphicsApiFilter()->setMajorVersion(2);
829	technique->graphicsApiFilter()->setMinorVersion(0);
830	technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
831
832	//Optional Core technique
833	QTechnique *coreTechnique = nullptr;
834	QTechnique *gl2Technique = nullptr;
835	QString coreTechniqueName = jsonObj.value(KEY_TECHNIQUE_CORE).toString();
836	if (!coreTechniqueName.isNull()) {
837	const auto it = std::as_const(t&: m_techniques).find(key: coreTechniqueName);
838	if (Q_UNLIKELY(it == m_techniques.cend())) {
839	qCWarning(GLTFImporterLog, "unknown technique %ls for material %ls in GLTF file %ls",
840	qUtf16PrintableImpl(coreTechniqueName), qUtf16PrintableImpl(id), qUtf16PrintableImpl(m_basePath));
841	} else {
842	coreTechnique = it.value();
843	coreTechnique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
844	coreTechnique->graphicsApiFilter()->setMajorVersion(3);
845	coreTechnique->graphicsApiFilter()->setMinorVersion(1);
846	coreTechnique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);
847	}
848	}
849	//Optional GL2 technique
850	QString gl2TechniqueName = jsonObj.value(KEY_TECHNIQUE_GL2).toString();
851	if (!gl2TechniqueName.isNull()) {
852	const auto it = std::as_const(t&: m_techniques).find(key: gl2TechniqueName);
853	if (Q_UNLIKELY(it == m_techniques.cend())) {
854	qCWarning(GLTFImporterLog, "unknown technique %ls for material %ls in GLTF file %ls",
855	qUtf16PrintableImpl(gl2TechniqueName), qUtf16PrintableImpl(id), qUtf16PrintableImpl(m_basePath));
856	} else {
857	gl2Technique = it.value();
858	gl2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
859	gl2Technique->graphicsApiFilter()->setMajorVersion(2);
860	gl2Technique->graphicsApiFilter()->setMinorVersion(0);
861	gl2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
862	}
863	}
864
865	// glTF doesn't deal in effects, but we need a trivial one to wrap
866	// up our techniques
867	// However we need to create a unique effect for each material instead
868	// of caching because QMaterial does not keep up with effects
869	// its not the parent of.
870	QEffect *effect = new QEffect;
871	effect->setObjectName(techniqueName);
872	effect->addTechnique(t: technique);
873	if (coreTechnique != nullptr)
874	effect->addTechnique(t: coreTechnique);
875	if (gl2Technique != nullptr)
876	effect->addTechnique(t: gl2Technique);
877
878	QMaterial *mat = new QMaterial;
879	mat->setEffect(effect);
880
881	renameFromJson(json: jsonObj, object: mat);
882
883	const QJsonObject values = jsonObj.value(KEY_VALUES).toObject();
884	for (auto it = values.begin(), end = values.end(); it != end; ++it) {
885	const QString vName = it.key();
886	QParameter *param = parameterFromTechnique(technique, parameterName: vName);
887
888	if (param == nullptr && coreTechnique != nullptr)
889	param = parameterFromTechnique(technique: coreTechnique, parameterName: vName);
890
891	if (param == nullptr && gl2Technique != nullptr)
892	param = parameterFromTechnique(technique: gl2Technique, parameterName: vName);
893
894	if (Q_UNLIKELY(!param)) {
895	qCWarning(GLTFImporterLog, "unknown parameter: %ls in technique %ls processing material %ls",
896	qUtf16PrintableImpl(vName), qUtf16PrintableImpl(techniqueName), qUtf16PrintableImpl(id));
897	continue;
898	}
899
900	ParameterData paramData = m_parameterDataDict.value(key: param);
901	QVariant var = parameterValueFromJSON(type: paramData.type, value: it.value());
902
903	mat->addParameter(parameter: new QParameter(param->name(), var));
904	} // of material technique-instance values iteration
905
906	return mat;
907	} else {
908	// Qt3D exported QGLTF custom material
909	QMaterial *mat = new QMaterial;
910	renameFromJson(json: jsonObj, object: mat);
911	QEffect *effect = m_effects.value(key: effectName);
912	if (effect) {
913	mat->setEffect(effect);
914	} else {
915	qCWarning(GLTFImporterLog, "Effect %ls missing for material %ls",
916	qUtf16PrintableImpl(effectName), qUtf16PrintableImpl(mat->objectName()));
917	}
918	const QJsonObject params = jsonObj.value(KEY_PARAMETERS).toObject();
919	for (auto it = params.begin(), end = params.end(); it != end; ++it)
920	mat->addParameter(parameter: buildParameter(key: it.key(), paramObj: it.value().toObject()));
921
922	return mat;
923	}
924	}
925
926	QMaterial *GLTFImporter::commonMaterial(const QJsonObject &jsonObj)
927	{
928	const auto jsonExt =
929	jsonObj.value(KEY_EXTENSIONS).toObject().value(KEY_COMMON_MAT).toObject();
930	if (m_majorVersion == 1 && jsonExt.isEmpty())
931	return nullptr;
932
933	QVariantHash params;
934	bool hasDiffuseMap = false;
935	bool hasSpecularMap = false;
936	bool hasNormalMap = false;
937	bool hasAlpha = false;
938
939	if (m_majorVersion > 1) {
940	QMaterial *mat = pbrMaterial(jsonObj);
941
942	if (mat)
943	return mat;
944	}
945
946	const QJsonObject values = jsonExt.value(KEY_VALUES).toObject();
947	for (auto it = values.begin(), end = values.end(); it != end; ++it) {
948	const QString vName = it.key();
949	const QJsonValue val = it.value();
950	QVariant var;
951	QString propertyName = vName;
952	if (vName == QLatin1String("ambient") && val.isArray()) {
953	var = vec4ToColorVariant(vec4Var: parameterValueFromJSON(GL_FLOAT_VEC4, value: val));
954	} else if (vName == QLatin1String("diffuse")) {
955	if (val.isString()) {
956	var = parameterValueFromJSON(GL_SAMPLER_2D, value: val);
957	hasDiffuseMap = true;
958	} else if (val.isArray()) {
959	var = vec4ToColorVariant(vec4Var: parameterValueFromJSON(GL_FLOAT_VEC4, value: val));
960	}
961	} else if (vName == QLatin1String("specular")) {
962	if (val.isString()) {
963	var = parameterValueFromJSON(GL_SAMPLER_2D, value: val);
964	hasSpecularMap = true;
965	} else if (val.isArray()) {
966	var = vec4ToColorVariant(vec4Var: parameterValueFromJSON(GL_FLOAT_VEC4, value: val));
967	}
968	} else if (vName == QLatin1String("cool")) { // Custom Qt3D extension for gooch
969	var = vec4ToColorVariant(vec4Var: parameterValueFromJSON(GL_FLOAT_VEC4, value: val));
970	} else if (vName == QLatin1String("warm")) { // Custom Qt3D extension for gooch
971	var = vec4ToColorVariant(vec4Var: parameterValueFromJSON(GL_FLOAT_VEC4, value: val));
972	} else if (vName == QLatin1String("shininess") && val.isDouble()) {
973	var = parameterValueFromJSON(GL_FLOAT, value: val);
974	} else if (vName == QLatin1String("normalmap") && val.isString()) {
975	var = parameterValueFromJSON(GL_SAMPLER_2D, value: val);
976	propertyName = QStringLiteral("normal");
977	hasNormalMap = true;
978	} else if (vName == QLatin1String("transparency")) {
979	var = parameterValueFromJSON(GL_FLOAT, value: val);
980	propertyName = QStringLiteral("alpha");
981	hasAlpha = true;
982	} else if (vName == QLatin1String("transparent")) {
983	hasAlpha = parameterValueFromJSON(GL_BOOL, value: val).toBool();
984	} else if (vName == QLatin1String("textureScale")) {
985	var = parameterValueFromJSON(GL_FLOAT, value: val);
986	propertyName = QStringLiteral("textureScale");
987	} else if (vName == QLatin1String("alpha")) { // Custom Qt3D extension for gooch
988	var = parameterValueFromJSON(GL_FLOAT, value: val);
989	} else if (vName == QLatin1String("beta")) { // Custom Qt3D extension for gooch
990	var = parameterValueFromJSON(GL_FLOAT, value: val);
991	}
992	if (var.isValid())
993	params[propertyName] = var;
994	}
995
996	const QJsonObject funcValues = jsonExt.value(KEY_FUNCTIONS).toObject();
997	if (!funcValues.isEmpty()) {
998	const QJsonArray fArray = funcValues[KEY_BLEND_FUNCTION].toArray();
999	const QJsonArray eArray = funcValues[KEY_BLEND_EQUATION].toArray();
1000	if (fArray.size() == 4) {
1001	params[QStringLiteral("sourceRgbArg")] = fArray[0].toInt();
1002	params[QStringLiteral("sourceAlphaArg")] = fArray[1].toInt();
1003	params[QStringLiteral("destinationRgbArg")] = fArray[2].toInt();
1004	params[QStringLiteral("destinationAlphaArg")] = fArray[3].toInt();
1005	}
1006	// We get separate values but our QPhongAlphaMaterial only supports single argument,
1007	// so we just use the first one.
1008	if (eArray.size() == 2)
1009	params[QStringLiteral("blendFunctionArg")] = eArray[0].toInt();
1010	}
1011
1012	QMaterial *mat = nullptr;
1013	const QString technique = jsonExt.value(KEY_TECHNIQUE).toString();
1014	if (technique == QStringLiteral("PHONG")) {
1015	if (hasNormalMap) {
1016	if (hasSpecularMap) {
1017	mat = new QNormalDiffuseSpecularMapMaterial;
1018	} else {
1019	if (Q_UNLIKELY(!hasDiffuseMap)) {
1020	qCWarning(GLTFImporterLog, "Common material with normal and specular maps needs a diffuse map as well");
1021	} else {
1022	if (hasAlpha)
1023	mat = new QNormalDiffuseMapAlphaMaterial;
1024	else
1025	mat = new QNormalDiffuseMapMaterial;
1026	}
1027	}
1028	} else {
1029	if (hasSpecularMap) {
1030	if (Q_UNLIKELY(!hasDiffuseMap))
1031	qCWarning(GLTFImporterLog, "Common material with specular map needs a diffuse map as well");
1032	else
1033	mat = new QDiffuseSpecularMapMaterial;
1034	} else if (hasDiffuseMap) {
1035	mat = new QDiffuseMapMaterial;
1036	} else {
1037	if (hasAlpha)
1038	mat = new QPhongAlphaMaterial;
1039	else
1040	mat = new QPhongMaterial;
1041	}
1042	}
1043	} else if (technique == QStringLiteral("GOOCH")) { // Qt3D specific extension
1044	mat = new QGoochMaterial;
1045	} else if (technique == QStringLiteral("PERVERTEX")) { // Qt3D specific extension
1046	mat = new QPerVertexColorMaterial;
1047	}
1048
1049	if (Q_UNLIKELY(!mat)) {
1050	qCWarning(GLTFImporterLog, "Could not find a suitable built-in material for KHR_materials_common");
1051	} else {
1052	for (QVariantHash::const_iterator it = params.constBegin(), itEnd = params.constEnd(); it != itEnd; ++it)
1053	mat->setProperty(name: it.key().toUtf8(), value: it.value());
1054
1055	renameFromJson(json: jsonObj, object: mat);
1056	}
1057
1058	return mat;
1059	}
1060
1061	QMaterial *GLTFImporter::pbrMaterial(const QJsonObject &jsonObj)
1062	{
1063	// check for pbrMetallicRoughness material
1064	QMetalRoughMaterial *mrMaterial = nullptr;
1065	QJsonValue jsonValue = jsonObj.value(KEY_PBR_METAL_ROUGH);
1066
1067	if (!jsonValue.isUndefined()) {
1068	const QJsonObject pbrObj = jsonValue.toObject();
1069	mrMaterial = new QMetalRoughMaterial;
1070	jsonValue = pbrObj.value(KEY_BASE_COLOR);
1071	if (!jsonValue.isUndefined())
1072	mrMaterial->setBaseColor(jsonArrToColorVariant(array: jsonValue.toArray()));
1073
1074	jsonValue = pbrObj.value(KEY_BASE_COLOR_TEX);
1075	if (!jsonValue.isUndefined()) {
1076	const QJsonObject texObj = jsonValue.toObject();
1077	const QString textureId = QString::number(texObj.value(KEY_INDEX).toInt());
1078	const auto it = m_textures.find(key: textureId);
1079	if (Q_UNLIKELY(it == m_textures.end())) {
1080	qCWarning(GLTFImporterLog, "unknown texture %ls", qUtf16PrintableImpl(textureId));
1081	} else {
1082	mrMaterial->setBaseColor(QVariant::fromValue(value: it.value()));
1083	}
1084	}
1085
1086	jsonValue = pbrObj.value(KEY_METAL_FACTOR);
1087	if (!jsonValue.isUndefined())
1088	mrMaterial->setMetalness(jsonValue.toVariant());
1089
1090	jsonValue = pbrObj.value(KEY_METAL_ROUGH_TEX);
1091	if (!jsonValue.isUndefined()) {
1092	const QJsonObject texObj = jsonValue.toObject();
1093	const QString textureId = QString::number(texObj.value(KEY_INDEX).toInt());
1094	const auto it = m_textures.find(key: textureId);
1095	if (Q_UNLIKELY(it == m_textures.end())) {
1096	qCWarning(GLTFImporterLog, "unknown texture %ls", qUtf16PrintableImpl(textureId));
1097	} else {
1098	// find the texture again
1099	const QJsonArray texArray = m_json.object().value(KEY_TEXTURES).toArray();
1100	const QJsonObject tObj = texArray.at(i: texObj.value(KEY_INDEX).toInt()).toObject();
1101	const QString sourceId = QString::number(tObj.value(KEY_SOURCE).toInt());
1102	QImage image;
1103	if (m_imagePaths.contains(key: sourceId)) {
1104	image.load(fileName: m_imagePaths.value(key: sourceId));
1105	} else if (m_imageData.contains(key: sourceId)) {
1106	image = m_imageData.value(key: sourceId);
1107	} else {
1108	return mrMaterial;
1109	}
1110
1111	// at this point, in image there is data for metalness (on B) and
1112	// roughness (on G) bytes. 2 new textures are created
1113	// to make Qt3D happy, since it samples only on R.
1114
1115	QTexture2D* metalTex = new QTexture2D;
1116	QTexture2D* roughTex = new QTexture2D;
1117	GLTFRawTextureImage* metalImgTex = new GLTFRawTextureImage();
1118	GLTFRawTextureImage* roughImgTex = new GLTFRawTextureImage();
1119	QImage metalness(image.size(), image.format());
1120	QImage roughness(image.size(), image.format());
1121
1122	const uchar *imgData = image.constBits();
1123	const int pixelBytes = image.depth() / 8;
1124	Q_ASSERT_X(pixelBytes < 3, "GLTFImporter::pbrMaterial", "Unsupported texture format");
1125
1126	for (int y = 0; y < image.height(); y++) {
1127	for (int x = 0; x < image.width(); x++) {
1128	metalness.setPixel(x, y, index_or_rgb: qRgb(r: imgData[0], g: imgData[0], b: imgData[0]));
1129	roughness.setPixel(x, y, index_or_rgb: qRgb(r: imgData[1], g: imgData[1], b: imgData[1]));
1130	imgData += pixelBytes;
1131	}
1132	}
1133
1134	metalImgTex->setImage(metalness);
1135	metalTex->addTextureImage(textureImage: metalImgTex);
1136	roughImgTex->setImage(roughness);
1137	roughTex->addTextureImage(textureImage: roughImgTex);
1138
1139	setTextureSamplerInfo(id: "", jsonObj: tObj, tex: metalTex);
1140	setTextureSamplerInfo(id: "", jsonObj: tObj, tex: roughTex);
1141
1142	mrMaterial->setMetalness(QVariant::fromValue(value: metalTex));
1143	mrMaterial->setRoughness(QVariant::fromValue(value: roughTex));
1144	}
1145	}
1146
1147	jsonValue = pbrObj.value(KEY_ROUGH_FACTOR);
1148	if (!jsonValue.isUndefined())
1149	mrMaterial->setRoughness(jsonValue.toVariant());
1150	}
1151
1152	jsonValue = jsonObj.value(KEY_NORMAL_TEX);
1153	if (!jsonValue.isUndefined()) {
1154	const QJsonObject texObj = jsonValue.toObject();
1155	const QString textureId = QString::number(texObj.value(KEY_INDEX).toInt());
1156	const auto it = m_textures.find(key: textureId);
1157	if (Q_UNLIKELY(it == m_textures.end())) {
1158	qCWarning(GLTFImporterLog, "unknown texture %ls", qUtf16PrintableImpl(textureId));
1159	} else {
1160	if (mrMaterial)
1161	mrMaterial->setNormal(QVariant::fromValue(value: it.value()));
1162	}
1163	}
1164
1165	jsonValue = jsonObj.value(KEY_OCCLUSION_TEX);
1166	if (!jsonValue.isUndefined()) {
1167	const QJsonObject texObj = jsonValue.toObject();
1168	const QString textureId = QString::number(texObj.value(KEY_INDEX).toInt());
1169	const auto it = m_textures.find(key: textureId);
1170	if (Q_UNLIKELY(it == m_textures.end())) {
1171	qCWarning(GLTFImporterLog, "unknown texture %ls", qUtf16PrintableImpl(textureId));
1172	} else {
1173	if (mrMaterial)
1174	mrMaterial->setAmbientOcclusion(QVariant::fromValue(value: it.value()));
1175	}
1176	}
1177
1178	return mrMaterial;
1179	}
1180
1181	QMaterial* GLTFImporter::material(const QString &id)
1182	{
1183	const auto it = std::as_const(t&: m_materialCache).find(key: id);
1184	if (it != m_materialCache.cend())
1185	return it.value();
1186
1187	QJsonValue jsonVal;
1188
1189	if (m_majorVersion > 1) {
1190	const QJsonArray mats = m_json.object().value(KEY_MATERIALS).toArray();
1191	jsonVal = mats.at(i: id.toInt());
1192	} else {
1193	const QJsonObject mats = m_json.object().value(KEY_MATERIALS).toObject();
1194	jsonVal = mats.value(key: id);
1195	}
1196
1197	if (Q_UNLIKELY(jsonVal.isUndefined())) {
1198	qCWarning(GLTFImporterLog, "unknown material %ls in GLTF file %ls",
1199	qUtf16PrintableImpl(id), qUtf16PrintableImpl(m_basePath));
1200	return nullptr;
1201	}
1202
1203	const QJsonObject jsonObj = jsonVal.toObject();
1204
1205	QMaterial *mat = nullptr;
1206
1207	// Prefer common materials over custom shaders.
1208	mat = commonMaterial(jsonObj);
1209	if (!mat)
1210	mat = materialWithCustomShader(id, jsonObj);
1211
1212	m_materialCache[id] = mat;
1213	return mat;
1214	}
1215
1216	bool GLTFImporter::fillCamera(QCameraLens &lens, QCamera *cameraEntity, const QString &id) const
1217	{
1218	QJsonObject jsonObj;
1219
1220	if (m_majorVersion > 1) {
1221	const QJsonArray camArray = m_json.object().value(KEY_CAMERAS).toArray();
1222	if (id.toInt() >= camArray.count()) {
1223	qCWarning(GLTFImporterLog, "unknown camera %ls in GLTF file %ls",
1224	qUtf16PrintableImpl(id), qUtf16PrintableImpl(m_basePath));
1225	return false;
1226	}
1227	jsonObj = camArray[id.toInt()].toObject();
1228	} else {
1229	const auto jsonVal = m_json.object().value(KEY_CAMERAS).toObject().value(key: id);
1230	if (Q_UNLIKELY(jsonVal.isUndefined())) {
1231	qCWarning(GLTFImporterLog, "unknown camera %ls in GLTF file %ls",
1232	qUtf16PrintableImpl(id), qUtf16PrintableImpl(m_basePath));
1233	return false;
1234	}
1235	jsonObj = jsonVal.toObject();
1236	}
1237
1238	QString camTy = jsonObj.value(KEY_TYPE).toString();
1239
1240	if (camTy == QLatin1String("perspective")) {
1241	const auto pVal = jsonObj.value(KEY_PERSPECTIVE);
1242	if (Q_UNLIKELY(pVal.isUndefined())) {
1243	qCWarning(GLTFImporterLog, "camera: %ls missing 'perspective' object",
1244	qUtf16PrintableImpl(id));
1245	return false;
1246	}
1247
1248	const QJsonObject pObj = pVal.toObject();
1249	double aspectRatio = pObj.value(KEY_ASPECT_RATIO).toDouble();
1250	double yfov = pObj.value(KEY_YFOV).toDouble();
1251	double frustumNear = pObj.value(KEY_ZNEAR).toDouble();
1252	double frustumFar = pObj.value(KEY_ZFAR).toDouble();
1253
1254	lens.setPerspectiveProjection(fieldOfView: qRadiansToDegrees(radians: yfov), aspect: aspectRatio, nearPlane: frustumNear,
1255	farPlane: frustumFar);
1256	} else if (camTy == QLatin1String("orthographic")) {
1257	const auto pVal = jsonObj.value(KEY_ORTHOGRAPHIC);
1258	if (Q_UNLIKELY(pVal.isUndefined())) {
1259	qCWarning(GLTFImporterLog, "camera: %ls missing 'orthographic' object",
1260	qUtf16PrintableImpl(id));
1261	return false;
1262	}
1263
1264	const QJsonObject pObj = pVal.toObject();
1265	double xmag = pObj.value(KEY_XMAG).toDouble() / 2.0f;
1266	double ymag = pObj.value(KEY_YMAG).toDouble() / 2.0f;
1267	double frustumNear = pObj.value(KEY_ZNEAR).toDouble();
1268	double frustumFar = pObj.value(KEY_ZFAR).toDouble();
1269
1270	lens.setOrthographicProjection(left: -xmag, right: xmag, bottom: -ymag, top: ymag, nearPlane: frustumNear, farPlane: frustumFar);
1271	} else {
1272	qCWarning(GLTFImporterLog, "camera: %ls has unsupported type: %ls",
1273	qUtf16PrintableImpl(id), qUtf16PrintableImpl(camTy));
1274	return false;
1275	}
1276	if (cameraEntity) {
1277	if (jsonObj.contains(KEY_POSITION))
1278	cameraEntity->setPosition(jsonArrToVec3(array: jsonObj.value(KEY_POSITION).toArray()));
1279	if (jsonObj.contains(KEY_UPVECTOR))
1280	cameraEntity->setUpVector(jsonArrToVec3(array: jsonObj.value(KEY_UPVECTOR).toArray()));
1281	if (jsonObj.contains(KEY_VIEW_CENTER))
1282	cameraEntity->setViewCenter(jsonArrToVec3(array: jsonObj.value(KEY_VIEW_CENTER).toArray()));
1283	}
1284	renameFromJson(json: jsonObj, object: &lens);
1285	return true;
1286	}
1287
1288	void GLTFImporter::parse()
1289	{
1290	if (m_parseDone)
1291	return;
1292
1293	const QJsonValue asset = m_json.object().value(KEY_ASSET);
1294	if (!asset.isUndefined())
1295	processJSONAsset(json: asset.toObject());
1296
1297	if (m_majorVersion > 1) {
1298	parseV2();
1299	} else {
1300	parseV1();
1301	}
1302
1303	m_parseDone = true;
1304	}
1305
1306	void GLTFImporter::parseV1()
1307	{
1308	const QJsonObject buffers = m_json.object().value(KEY_BUFFERS).toObject();
1309	for (auto it = buffers.begin(), end = buffers.end(); it != end; ++it)
1310	processJSONBuffer(id: it.key(), json: it.value().toObject());
1311
1312	const QJsonObject views = m_json.object().value(KEY_BUFFER_VIEWS).toObject();
1313	loadBufferData();
1314	for (auto it = views.begin(), end = views.end(); it != end; ++it)
1315	processJSONBufferView(id: it.key(), json: it.value().toObject());
1316	unloadBufferData();
1317
1318	const QJsonObject shaders = m_json.object().value(KEY_SHADERS).toObject();
1319	for (auto it = shaders.begin(), end = shaders.end(); it != end; ++it)
1320	processJSONShader(id: it.key(), jsonObject: it.value().toObject());
1321
1322	const QJsonObject programs = m_json.object().value(KEY_PROGRAMS).toObject();
1323	for (auto it = programs.begin(), end = programs.end(); it != end; ++it)
1324	processJSONProgram(id: it.key(), jsonObject: it.value().toObject());
1325
1326	const QJsonObject attrs = m_json.object().value(KEY_ACCESSORS).toObject();
1327	for (auto it = attrs.begin(), end = attrs.end(); it != end; ++it)
1328	processJSONAccessor(id: it.key(), json: it.value().toObject());
1329
1330	const QJsonObject meshes = m_json.object().value(KEY_MESHES).toObject();
1331	for (auto it = meshes.begin(), end = meshes.end(); it != end; ++it)
1332	processJSONMesh(id: it.key(), json: it.value().toObject());
1333
1334	const QJsonObject images = m_json.object().value(KEY_IMAGES).toObject();
1335	for (auto it = images.begin(), end = images.end(); it != end; ++it)
1336	processJSONImage(id: it.key(), jsonObject: it.value().toObject());
1337
1338	const QJsonObject textures = m_json.object().value(KEY_TEXTURES).toObject();
1339	for (auto it = textures.begin(), end = textures.end(); it != end; ++it)
1340	processJSONTexture(id: it.key(), jsonObject: it.value().toObject());
1341
1342	const QJsonObject extensions = m_json.object().value(KEY_EXTENSIONS).toObject();
1343	for (auto it = extensions.begin(), end = extensions.end(); it != end; ++it)
1344	processJSONExtensions(id: it.key(), jsonObject: it.value().toObject());
1345
1346	const QJsonObject passes = m_json.object().value(KEY_RENDERPASSES).toObject();
1347	for (auto it = passes.begin(), end = passes.end(); it != end; ++it)
1348	processJSONRenderPass(id: it.key(), jsonObject: it.value().toObject());
1349
1350	const QJsonObject techniques = m_json.object().value(KEY_TECHNIQUES).toObject();
1351	for (auto it = techniques.begin(), end = techniques.end(); it != end; ++it)
1352	processJSONTechnique(id: it.key(), jsonObject: it.value().toObject());
1353
1354	const QJsonObject effects = m_json.object().value(KEY_EFFECTS).toObject();
1355	for (auto it = effects.begin(), end = effects.end(); it != end; ++it)
1356	processJSONEffect(id: it.key(), jsonObject: it.value().toObject());
1357
1358	m_defaultScene = m_json.object().value(KEY_SCENE).toString();
1359	}
1360
1361	void GLTFImporter::parseV2()
1362	{
1363	int i;
1364	const QJsonArray buffers = m_json.object().value(KEY_BUFFERS).toArray();
1365	for (i = 0; i < buffers.count(); i++)
1366	processJSONBuffer(id: QString::number(i), json: buffers[i].toObject());
1367
1368	const QJsonArray views = m_json.object().value(KEY_BUFFER_VIEWS).toArray();
1369	loadBufferData();
1370	for (i = 0; i < views.count(); i++)
1371	processJSONBufferView(id: QString::number(i), json: views[i].toObject());
1372	unloadBufferData();
1373
1374	const QJsonArray accessors = m_json.object().value(KEY_ACCESSORS).toArray();
1375	for (i = 0; i < accessors.count(); i++)
1376	processJSONAccessor(id: QString::number(i), json: accessors[i].toObject());
1377
1378	const QJsonArray meshes = m_json.object().value(KEY_MESHES).toArray();
1379	for (i = 0; i < meshes.count(); i++)
1380	processJSONMesh(id: QString::number(i), json: meshes[i].toObject());
1381
1382	const QJsonArray images = m_json.object().value(KEY_IMAGES).toArray();
1383	for (i = 0; i < images.count(); i++)
1384	processJSONImage(id: QString::number(i), jsonObject: images[i].toObject());
1385
1386	const QJsonArray textures = m_json.object().value(KEY_TEXTURES).toArray();
1387	for (i = 0; i < textures.count(); i++)
1388	processJSONTexture(id: QString::number(i), jsonObject: textures[i].toObject());
1389
1390	m_defaultScene = QString::number(m_json.object().value(KEY_SCENE).toInt());
1391	}
1392
1393	namespace {
1394	template <typename C>
1395	void delete_if_without_parent(const C &c)
1396	{
1397	for (const auto *e : c) {
1398	if (!e->parent())
1399	delete e;
1400	}
1401	}
1402	} // unnamed namespace
1403
1404	void GLTFImporter::cleanup()
1405	{
1406	m_meshDict.clear();
1407	m_meshMaterialDict.clear();
1408	m_accessorDict.clear();
1409	delete_if_without_parent(c: m_materialCache);
1410	m_materialCache.clear();
1411	m_bufferDatas.clear();
1412	m_buffers.clear();
1413	m_shaderPaths.clear();
1414	delete_if_without_parent(c: m_programs);
1415	m_programs.clear();
1416	for (const auto &params : std::as_const(t&: m_techniqueParameters))
1417	delete_if_without_parent(c: params);
1418	m_techniqueParameters.clear();
1419	delete_if_without_parent(c: m_techniques);
1420	m_techniques.clear();
1421	delete_if_without_parent(c: m_textures);
1422	m_textures.clear();
1423	m_imagePaths.clear();
1424	m_imageData.clear();
1425	m_defaultScene.clear();
1426	m_parameterDataDict.clear();
1427	delete_if_without_parent(c: m_renderPasses);
1428	m_renderPasses.clear();
1429	delete_if_without_parent(c: m_effects);
1430	m_effects.clear();
1431	}
1432
1433	void GLTFImporter::processJSONAsset(const QJsonObject &json)
1434	{
1435	const QString version = json.value(KEY_VERSION).toString();
1436	if (!version.isEmpty()) {
1437	const QStringList verTokens = version.split(sep: '.');
1438	if (verTokens.size() >= 2) {
1439	m_majorVersion = verTokens[0].toInt();
1440	m_minorVersion = verTokens[1].toInt();
1441	}
1442	}
1443	}
1444
1445	void GLTFImporter::processJSONBuffer(const QString &id, const QJsonObject& json)
1446	{
1447	// simply cache buffers for lookup by buffer-views
1448	m_bufferDatas[id] = BufferData(json);
1449	}
1450
1451	void GLTFImporter::processJSONBufferView(const QString &id, const QJsonObject& json)
1452	{
1453	QString bufName;
1454	if (m_majorVersion > 1) {
1455	bufName = QString::number(json.value(KEY_BUFFER).toInt());
1456	} else {
1457	bufName = json.value(KEY_BUFFER).toString();
1458	}
1459	const auto it = std::as_const(t&: m_bufferDatas).find(key: bufName);
1460	if (Q_UNLIKELY(it == m_bufferDatas.cend())) {
1461	qCWarning(GLTFImporterLog, "unknown buffer: %ls processing view: %ls",
1462	qUtf16PrintableImpl(bufName), qUtf16PrintableImpl(id));
1463	return;
1464	}
1465	const auto &bufferData = *it;
1466
1467	quint64 offset = 0;
1468	const auto byteOffset = json.value(KEY_BYTE_OFFSET);
1469	if (!byteOffset.isUndefined()) {
1470	offset = byteOffset.toInt();
1471	qCDebug(GLTFImporterLog, "bv: %ls has offset: %lld", qUtf16PrintableImpl(id), offset);
1472	}
1473
1474	quint64 len = json.value(KEY_BYTE_LENGTH).toInt();
1475
1476	QByteArray bytes = bufferData.data->mid(index: offset, len);
1477	if (Q_UNLIKELY(bytes.size() != qsizetype(len))) {
1478	qCWarning(GLTFImporterLog, "failed to read sufficient bytes from: %ls for view %ls",
1479	qUtf16PrintableImpl(bufferData.path), qUtf16PrintableImpl(id));
1480	}
1481
1482	Qt3DCore::QBuffer *b = new Qt3DCore::QBuffer();
1483	b->setData(bytes);
1484	m_buffers[id] = b;
1485	}
1486
1487	void GLTFImporter::processJSONShader(const QString &id, const QJsonObject &jsonObject)
1488	{
1489	// shaders are trivial for the moment, defer the real work
1490	// to the program section
1491	QString path = jsonObject.value(KEY_URI).toString();
1492
1493	if (!isEmbeddedResource(url: path)) {
1494	QFileInfo info(m_basePath, path);
1495	if (Q_UNLIKELY(!info.exists())) {
1496	qCWarning(GLTFImporterLog, "can't find shader %ls from path %ls",
1497	qUtf16PrintableImpl(id), qUtf16PrintableImpl(path));
1498	return;
1499	}
1500
1501	m_shaderPaths[id] = info.absoluteFilePath();
1502	} else {
1503	const QByteArray base64Data = path.toLatin1().remove(index: 0, len: path.indexOf(s: ",") + 1);
1504	m_shaderPaths[id] = QString(QByteArray::fromBase64(base64: base64Data));
1505	}
1506
1507
1508	}
1509
1510	void GLTFImporter::processJSONProgram(const QString &id, const QJsonObject &jsonObject)
1511	{
1512	const QString fragName = jsonObject.value(KEY_FRAGMENT_SHADER).toString();
1513	const QString vertName = jsonObject.value(KEY_VERTEX_SHADER).toString();
1514
1515	const auto fragIt = std::as_const(t&: m_shaderPaths).find(key: fragName);
1516	const auto vertIt = std::as_const(t&: m_shaderPaths).find(key: vertName);
1517
1518	if (Q_UNLIKELY(fragIt == m_shaderPaths.cend() || vertIt == m_shaderPaths.cend())) {
1519	qCWarning(GLTFImporterLog, "program: %ls missing shader: %ls %ls",
1520	qUtf16PrintableImpl(id), qUtf16PrintableImpl(fragName), qUtf16PrintableImpl(vertName));
1521	return;
1522	}
1523
1524	QShaderProgram* prog = new QShaderProgram;
1525	prog->setObjectName(id);
1526	prog->setFragmentShaderCode(QShaderProgram::loadSource(sourceUrl: QUrl::fromLocalFile(localfile: fragIt.value())));
1527	prog->setVertexShaderCode(QShaderProgram::loadSource(sourceUrl: QUrl::fromLocalFile(localfile: vertIt.value())));
1528
1529	const QString tessCtrlName = jsonObject.value(KEY_TESS_CTRL_SHADER).toString();
1530	if (!tessCtrlName.isEmpty()) {
1531	const auto it = std::as_const(t&: m_shaderPaths).find(key: tessCtrlName);
1532	prog->setTessellationControlShaderCode(
1533	QShaderProgram::loadSource(sourceUrl: QUrl::fromLocalFile(localfile: it.value())));
1534	}
1535
1536	const QString tessEvalName = jsonObject.value(KEY_TESS_EVAL_SHADER).toString();
1537	if (!tessEvalName.isEmpty()) {
1538	const auto it = std::as_const(t&: m_shaderPaths).find(key: tessEvalName);
1539	prog->setTessellationEvaluationShaderCode(
1540	QShaderProgram::loadSource(sourceUrl: QUrl::fromLocalFile(localfile: it.value())));
1541	}
1542
1543	const QString geomName = jsonObject.value(KEY_GEOMETRY_SHADER).toString();
1544	if (!geomName.isEmpty()) {
1545	const auto it = std::as_const(t&: m_shaderPaths).find(key: geomName);
1546	prog->setGeometryShaderCode(QShaderProgram::loadSource(sourceUrl: QUrl::fromLocalFile(localfile: it.value())));
1547	}
1548
1549	const QString computeName = jsonObject.value(KEY_COMPUTE_SHADER).toString();
1550	if (!computeName.isEmpty()) {
1551	const auto it = std::as_const(t&: m_shaderPaths).find(key: computeName);
1552	prog->setComputeShaderCode(QShaderProgram::loadSource(sourceUrl: QUrl::fromLocalFile(localfile: it.value())));
1553	}
1554
1555	m_programs[id] = prog;
1556	}
1557
1558	void GLTFImporter::processJSONTechnique(const QString &id, const QJsonObject &jsonObject )
1559	{
1560	QTechnique *t = new QTechnique;
1561	t->setObjectName(id);
1562
1563	const QJsonObject gabifilter = jsonObject.value(KEY_GABIFILTER).toObject();
1564	if (gabifilter.isEmpty()) {
1565	// Regular GLTF technique
1566
1567	// Parameters
1568	QHash<QString, QParameter *> paramDict;
1569	const QJsonObject params = jsonObject.value(KEY_PARAMETERS).toObject();
1570	for (auto it = params.begin(), end = params.end(); it != end; ++it) {
1571	const QString pname = it.key();
1572	const QJsonObject po = it.value().toObject();
1573	QParameter *p = buildParameter(key: pname, paramObj: po);
1574	m_parameterDataDict.insert(key: p, value: ParameterData(po));
1575	// We don't want to insert invalid parameters to techniques themselves, but we
1576	// need to maintain link between all parameters and techniques so we can resolve
1577	// parameter type later when creating materials.
1578	if (p->value().isValid())
1579	t->addParameter(p);
1580	paramDict[pname] = p;
1581	}
1582
1583	// Program
1584	QRenderPass *pass = new QRenderPass;
1585	addProgramToPass(pass, progName: jsonObject.value(KEY_PROGRAM).toString());
1586
1587	// Attributes
1588	const QJsonObject attrs = jsonObject.value(KEY_ATTRIBUTES).toObject();
1589	for (auto it = attrs.begin(), end = attrs.end(); it != end; ++it) {
1590	QString pname = it.value().toString();
1591	QParameter *parameter = paramDict.value(key: pname, defaultValue: nullptr);
1592	QString attributeName = pname;
1593	if (Q_UNLIKELY(!parameter)) {
1594	qCWarning(GLTFImporterLog, "attribute %ls defined in instanceProgram but not as parameter",
1595	qUtf16PrintableImpl(pname));
1596	continue;
1597	}
1598	//Check if the parameter has a standard attribute semantic
1599	const auto paramDataIt = m_parameterDataDict.find(key: parameter);
1600	QString standardAttributeName = standardAttributeNameFromSemantic(semantic: paramDataIt->semantic);
1601	if (!standardAttributeName.isNull()) {
1602	attributeName = standardAttributeName;
1603	t->removeParameter(p: parameter);
1604	m_parameterDataDict.erase(it: paramDataIt);
1605	paramDict.remove(key: pname);
1606	delete parameter;
1607	}
1608
1609	} // of program-instance attributes
1610
1611	// Uniforms
1612	const QJsonObject uniforms = jsonObject.value(KEY_UNIFORMS).toObject();
1613	for (auto it = uniforms.begin(), end = uniforms.end(); it != end; ++it) {
1614	const QString pname = it.value().toString();
1615	QParameter *parameter = paramDict.value(key: pname, defaultValue: nullptr);
1616	if (Q_UNLIKELY(!parameter)) {
1617	qCWarning(GLTFImporterLog, "uniform %ls defined in instanceProgram but not as parameter",
1618	qUtf16PrintableImpl(pname));
1619	continue;
1620	}
1621	//Check if the parameter has a standard uniform semantic
1622	const auto paramDataIt = m_parameterDataDict.find(key: parameter);
1623	if (hasStandardUniformNameFromSemantic(semantic: paramDataIt->semantic)) {
1624	t->removeParameter(p: parameter);
1625	m_parameterDataDict.erase(it: paramDataIt);
1626	paramDict.remove(key: pname);
1627	delete parameter;
1628	}
1629	} // of program-instance uniforms
1630
1631	m_techniqueParameters.insert(key: t, value: paramDict.values());
1632
1633	populateRenderStates(pass, states: jsonObject.value(KEY_STATES).toObject());
1634
1635	t->addRenderPass(pass);
1636	} else {
1637	// Qt3D exported custom technique
1638
1639	// Graphics API filter
1640	t->graphicsApiFilter()->setApi(QGraphicsApiFilter::Api(gabifilter.value(KEY_API).toInt()));
1641	t->graphicsApiFilter()->setMajorVersion(gabifilter.value(KEY_MAJORVERSION).toInt());
1642	t->graphicsApiFilter()->setMinorVersion(gabifilter.value(KEY_MINORVERSION).toInt());
1643	t->graphicsApiFilter()->setProfile(QGraphicsApiFilter::OpenGLProfile(
1644	gabifilter.value(KEY_PROFILE).toInt()));
1645	t->graphicsApiFilter()->setVendor(gabifilter.value(KEY_VENDOR).toString());
1646	QStringList extensionList;
1647	QJsonArray extArray = gabifilter.value(KEY_EXTENSIONS).toArray();
1648	for (const QJsonValue extValue : extArray)
1649	extensionList << extValue.toString();
1650	t->graphicsApiFilter()->setExtensions(extensionList);
1651
1652	// Filter keys (we will assume filter keys are always strings or integers)
1653	const QJsonObject fkObj = jsonObject.value(KEY_FILTERKEYS).toObject();
1654	for (auto it = fkObj.begin(), end = fkObj.end(); it != end; ++it)
1655	t->addFilterKey(filterKey: buildFilterKey(key: it.key(), val: it.value()));
1656
1657	t->setObjectName(jsonObject.value(KEY_NAME).toString());
1658
1659	// Parameters
1660	const QJsonObject params = jsonObject.value(KEY_PARAMETERS).toObject();
1661	for (auto it = params.begin(), end = params.end(); it != end; ++it)
1662	t->addParameter(p: buildParameter(key: it.key(), paramObj: it.value().toObject()));
1663
1664	// Render passes
1665	const QJsonArray passArray = jsonObject.value(KEY_RENDERPASSES).toArray();
1666	for (const QJsonValue passValue : passArray) {
1667	const QString passName = passValue.toString();
1668	QRenderPass *pass = m_renderPasses.value(key: passName);
1669	if (pass) {
1670	t->addRenderPass(pass);
1671	} else {
1672	qCWarning(GLTFImporterLog, "Render pass %ls missing for technique %ls",
1673	qUtf16PrintableImpl(passName), qUtf16PrintableImpl(id));
1674	}
1675	}
1676	}
1677
1678	m_techniques[id] = t;
1679	}
1680
1681	void GLTFImporter::processJSONAccessor(const QString &id, const QJsonObject& json)
1682	{
1683	m_accessorDict[id] = AccessorData(json, m_majorVersion, m_minorVersion);
1684	}
1685
1686	void GLTFImporter::processJSONMesh(const QString &id, const QJsonObject &json)
1687	{
1688	const QString meshName = json.value(KEY_NAME).toString();
1689	const QString meshType = json.value(KEY_TYPE).toString();
1690	if (meshType.isEmpty()) {
1691	// Custom mesh
1692	const QJsonArray primitivesArray = json.value(KEY_PRIMITIVES).toArray();
1693	for (const QJsonValue primitiveValue : primitivesArray) {
1694	const QJsonObject primitiveObject = primitiveValue.toObject();
1695	const QJsonValue type = primitiveObject.value(KEY_MODE);
1696	const QJsonValue matValue = primitiveObject.value(KEY_MATERIAL);
1697	const QString material = (m_majorVersion > 1) ? QString::number(matValue.toInt()) : matValue.toString();
1698
1699	QGeometryRenderer *geometryRenderer = new QGeometryRenderer;
1700	QGeometryView *geometryView = new QGeometryView;
1701	QGeometry *meshGeometry = new QGeometry(geometryRenderer);
1702
1703	//Set Primitive Type
1704	if (type.isUndefined()) {
1705	geometryRenderer->setPrimitiveType(QGeometryRenderer::Triangles);
1706	} else {
1707	geometryRenderer->setPrimitiveType(static_cast<QGeometryRenderer::PrimitiveType>(type.toInt()));
1708	}
1709
1710	//Save Material for mesh
1711	m_meshMaterialDict[geometryRenderer] = material;
1712
1713	const QJsonObject attrs = primitiveObject.value(KEY_ATTRIBUTES).toObject();
1714	for (auto it = attrs.begin(), end = attrs.end(); it != end; ++it) {
1715	const QString k = (m_majorVersion > 1) ? QString::number(it.value().toInt()) : it.value().toString();
1716	const auto accessorIt = std::as_const(t&: m_accessorDict).find(key: k);
1717	if (Q_UNLIKELY(accessorIt == m_accessorDict.cend())) {
1718	qCWarning(GLTFImporterLog, "unknown attribute accessor: %ls on mesh %ls",
1719	qUtf16PrintableImpl(k), qUtf16PrintableImpl(id));
1720	continue;
1721	}
1722
1723	const QString attrName = it.key();
1724	QString attributeName = standardAttributeNameFromSemantic(semantic: attrName);
1725	if (attributeName.isEmpty())
1726	attributeName = attrName;
1727
1728	//Get buffer handle for accessor
1729	Qt3DCore::QBuffer *buffer = m_buffers.value(key: accessorIt->bufferViewName, defaultValue: nullptr);
1730	if (Q_UNLIKELY(!buffer)) {
1731	qCWarning(GLTFImporterLog, "unknown buffer-view: %ls processing accessor: %ls",
1732	qUtf16PrintableImpl(accessorIt->bufferViewName),
1733	qUtf16PrintableImpl(id));
1734	continue;
1735	}
1736
1737	QAttribute *attribute = new QAttribute(buffer,
1738	attributeName,
1739	accessorIt->type,
1740	accessorIt->dataSize,
1741	accessorIt->count,
1742	accessorIt->offset,
1743	accessorIt->stride);
1744	attribute->setAttributeType(QAttribute::VertexAttribute);
1745	meshGeometry->addAttribute(attribute);
1746	}
1747
1748	const auto indices = primitiveObject.value(KEY_INDICES);
1749	if (!indices.isUndefined()) {
1750	const QString accIndex = (m_majorVersion > 1) ? QString::number(indices.toInt()) : indices.toString();
1751	const auto accessorIt = std::as_const(t&: m_accessorDict).find(key: accIndex);
1752	if (Q_UNLIKELY(accessorIt == m_accessorDict.cend())) {
1753	qCWarning(GLTFImporterLog, "unknown index accessor: %ls on mesh %ls",
1754	qUtf16PrintableImpl(accIndex), qUtf16PrintableImpl(id));
1755	} else {
1756	//Get buffer handle for accessor
1757	Qt3DCore::QBuffer *buffer = m_buffers.value(key: accessorIt->bufferViewName, defaultValue: nullptr);
1758	if (Q_UNLIKELY(!buffer)) {
1759	qCWarning(GLTFImporterLog, "unknown buffer-view: %ls processing accessor: %ls",
1760	qUtf16PrintableImpl(accessorIt->bufferViewName),
1761	qUtf16PrintableImpl(id));
1762	continue;
1763	}
1764
1765	QAttribute *attribute = new QAttribute(buffer,
1766	accessorIt->type,
1767	accessorIt->dataSize,
1768	accessorIt->count,
1769	accessorIt->offset,
1770	accessorIt->stride);
1771	attribute->setAttributeType(QAttribute::IndexAttribute);
1772	meshGeometry->addAttribute(attribute);
1773	}
1774	} // of has indices
1775
1776	geometryView->setGeometry(meshGeometry);
1777	geometryRenderer->setView(geometryView);
1778	geometryRenderer->setObjectName(meshName);
1779
1780	m_meshDict.insert(key: id, value: geometryRenderer);
1781	} // of primitives iteration
1782	} else {
1783	QGeometryRenderer *mesh = nullptr;
1784	if (meshType == QStringLiteral("cone")) {
1785	mesh = new QConeMesh;
1786	} else if (meshType == QStringLiteral("cuboid")) {
1787	mesh = new QCuboidMesh;
1788	} else if (meshType == QStringLiteral("cylinder")) {
1789	mesh = new QCylinderMesh;
1790	} else if (meshType == QStringLiteral("plane")) {
1791	mesh = new QPlaneMesh;
1792	} else if (meshType == QStringLiteral("sphere")) {
1793	mesh = new QSphereMesh;
1794	} else if (meshType == QStringLiteral("torus")) {
1795	mesh = new QTorusMesh;
1796	} else {
1797	qCWarning(GLTFImporterLog,
1798	"Invalid mesh type: %ls for mesh: %ls",
1799	qUtf16PrintableImpl(meshType),
1800	qUtf16PrintableImpl(id));
1801	}
1802
1803	if (mesh) {
1804	// Read and set properties
1805	const QJsonObject propObj = json.value(KEY_PROPERTIES).toObject();
1806	QObject *target = mesh;
1807	if (mesh->view())
1808	target = mesh->view();
1809	for (auto it = propObj.begin(), end = propObj.end(); it != end; ++it) {
1810	const QByteArray propName = it.key().toLatin1();
1811	// Basic mesh types only have bool, int, float, and QSize type properties
1812	if (it.value().isBool()) {
1813	target->setProperty(name: propName.constData(), value: QVariant(it.value().toBool()));
1814	} else if (it.value().isArray()) {
1815	const QJsonArray valueArray = it.value().toArray();
1816	if (valueArray.size() == 2) {
1817	QSize size;
1818	size.setWidth(valueArray.at(i: 0).toInt());
1819	size.setHeight(valueArray.at(i: 1).toInt());
1820	target->setProperty(name: propName.constData(), value: QVariant(size));
1821	}
1822	} else {
1823	const QMetaType propType = target->property(name: propName.constData()).metaType();
1824	if (propType.id() == QMetaType::Int) {
1825	target->setProperty(name: propName.constData(), value: QVariant(it.value().toInt()));
1826	} else {
1827	target->setProperty(name: propName.constData(),
1828	value: QVariant(float(it.value().toDouble())));
1829	}
1830	}
1831	}
1832	mesh->setObjectName(meshName);
1833	mesh->view()->setObjectName(meshName);
1834	m_meshMaterialDict[mesh] = (m_majorVersion > 1) ?
1835	QString::number(json.value(KEY_MATERIAL).toInt()) :
1836	json.value(KEY_MATERIAL).toString();
1837	m_meshDict.insert(key: id, value: mesh);
1838	}
1839	}
1840	}
1841
1842	void GLTFImporter::processJSONImage(const QString &id, const QJsonObject &jsonObject)
1843	{
1844	QString path = jsonObject.value(KEY_URI).toString();
1845
1846	if (!isEmbeddedResource(url: path)) {
1847	QFileInfo info(m_basePath, path);
1848	if (Q_UNLIKELY(!info.exists())) {
1849	qCWarning(GLTFImporterLog, "can't find image %ls from path %ls",
1850	qUtf16PrintableImpl(id), qUtf16PrintableImpl(path));
1851	return;
1852	}
1853
1854	m_imagePaths[id] = info.absoluteFilePath();
1855	} else {
1856	const QByteArray base64Data = path.toLatin1().remove(index: 0, len: path.indexOf(s: ",") + 1);
1857	QImage image;
1858	image.loadFromData(data: QByteArray::fromBase64(base64: base64Data));
1859	m_imageData[id] = image;
1860	}
1861	}
1862
1863	void GLTFImporter::processJSONTexture(const QString &id, const QJsonObject &jsonObject)
1864	{
1865	QJsonValue jsonVal = jsonObject.value(KEY_TARGET);
1866	if (!jsonVal.isUndefined()) {
1867	int target = jsonVal.toInt(GL_TEXTURE_2D);
1868	//TODO: support other targets that GL_TEXTURE_2D (though the spec doesn't support anything else)
1869	if (Q_UNLIKELY(target != GL_TEXTURE_2D)) {
1870	qCWarning(GLTFImporterLog, "unsupported texture target: %d", target);
1871	return;
1872	}
1873	}
1874
1875	QTexture2D* tex = new QTexture2D;
1876
1877	// TODO: Choose suitable internal format - may vary on OpenGL context type
1878	//int pixelFormat = jsonObj.value(KEY_FORMAT).toInt(GL_RGBA);
1879	int internalFormat = GL_RGBA;
1880	jsonVal = jsonObject.value(KEY_INTERNAL_FORMAT);
1881	if (!jsonVal.isUndefined())
1882	internalFormat = jsonObject.value(KEY_INTERNAL_FORMAT).toInt(GL_RGBA);
1883
1884	tex->setFormat(static_cast<QAbstractTexture::TextureFormat>(internalFormat));
1885
1886	QJsonValue srcValue = jsonObject.value(KEY_SOURCE);
1887	QString source = (m_majorVersion > 1) ? QString::number(srcValue.toInt()) : srcValue.toString();
1888
1889	const auto imagIt = std::as_const(t&: m_imagePaths).find(key: source);
1890	if (Q_UNLIKELY(imagIt == m_imagePaths.cend())) {
1891	// if an image is not found in paths, it probably means
1892	// it was an embedded resource, referenced in m_imageData
1893	const auto embImgIt = std::as_const(t&: m_imageData).find(key: source);
1894	if (Q_UNLIKELY(embImgIt == m_imageData.cend())) {
1895	qCWarning(GLTFImporterLog, "texture %ls references missing image %ls",
1896	qUtf16PrintableImpl(id), qUtf16PrintableImpl(source));
1897	return;
1898	}
1899
1900	QImage img = embImgIt.value();
1901	GLTFRawTextureImage *imageData = new GLTFRawTextureImage();
1902	imageData->setImage(img);
1903	tex->addTextureImage(textureImage: imageData);
1904	} else {
1905	QTextureImage *texImage = new QTextureImage(tex);
1906	texImage->setMirrored(false);
1907	texImage->setSource(QUrl::fromLocalFile(localfile: imagIt.value()));
1908	tex->addTextureImage(textureImage: texImage);
1909	}
1910
1911	setTextureSamplerInfo(id, jsonObj: jsonObject, tex);
1912
1913	m_textures[id] = tex;
1914	}
1915
1916	void GLTFImporter::processJSONExtensions(const QString &id, const QJsonObject &jsonObject)
1917	{
1918	// Lights are defined in "KHR_materials_common" property of "extensions" property of the top
1919	// level GLTF item.
1920	if (id == KEY_COMMON_MAT) {
1921	const auto lights = jsonObject.value(KEY_LIGHTS).toObject();
1922	const auto keys = lights.keys();
1923	for (const auto &lightKey : keys) {
1924	const auto light = lights.value(key: lightKey).toObject();
1925	auto lightType = light.value(KEY_TYPE).toString();
1926	const auto lightValues = light.value(key: lightType).toObject();
1927	QAbstractLight *lightComp = nullptr;
1928	if (lightType == KEY_DIRECTIONAL_LIGHT) {
1929	auto dirLight = new QDirectionalLight;
1930	dirLight->setWorldDirection(
1931	jsonArrToVec3(array: lightValues.value(KEY_DIRECTION).toArray()));
1932	lightComp = dirLight;
1933	} else if (lightType == KEY_SPOT_LIGHT) {
1934	auto spotLight = new QSpotLight;
1935	spotLight->setLocalDirection(
1936	jsonArrToVec3(array: lightValues.value(KEY_DIRECTION).toArray()));
1937	spotLight->setConstantAttenuation(
1938	lightValues.value(KEY_CONST_ATTENUATION).toDouble());
1939	spotLight->setLinearAttenuation(
1940	lightValues.value(KEY_LINEAR_ATTENUATION).toDouble());
1941	spotLight->setQuadraticAttenuation(
1942	lightValues.value(KEY_QUAD_ATTENUATION).toDouble());
1943	spotLight->setCutOffAngle(
1944	lightValues.value(KEY_FALLOFF_ANGLE).toDouble());
1945	lightComp = spotLight;
1946	} else if (lightType == KEY_POINT_LIGHT) {
1947	auto pointLight = new QPointLight;
1948	pointLight->setConstantAttenuation(
1949	lightValues.value(KEY_CONST_ATTENUATION).toDouble());
1950	pointLight->setLinearAttenuation(
1951	lightValues.value(KEY_LINEAR_ATTENUATION).toDouble());
1952	pointLight->setQuadraticAttenuation(
1953	lightValues.value(KEY_QUAD_ATTENUATION).toDouble());
1954	lightComp = pointLight;
1955	} else if (lightType == KEY_AMBIENT_LIGHT) {
1956	qCWarning(GLTFImporterLog, "Ambient lights are not supported.");
1957	} else {
1958	qCWarning(GLTFImporterLog, "Unknown light type: %ls",
1959	qUtf16PrintableImpl(lightType));
1960	}
1961
1962	if (lightComp) {
1963	auto colorVal = lightValues.value(KEY_COLOR);
1964	lightComp->setColor(vec4ToQColor(vec4Var: parameterValueFromJSON(GL_FLOAT_VEC4, value: colorVal)));
1965	lightComp->setIntensity(lightValues.value(KEY_INTENSITY).toDouble());
1966	lightComp->setObjectName(light.value(KEY_NAME).toString());
1967
1968	m_lights.insert(key: lightKey, value: lightComp);
1969	}
1970	}
1971	}
1972
1973	}
1974
1975	void GLTFImporter::processJSONEffect(const QString &id, const QJsonObject &jsonObject)
1976	{
1977	QEffect *effect = new QEffect;
1978	renameFromJson(json: jsonObject, object: effect);
1979
1980	const QJsonObject params = jsonObject.value(KEY_PARAMETERS).toObject();
1981	for (auto it = params.begin(), end = params.end(); it != end; ++it)
1982	effect->addParameter(parameter: buildParameter(key: it.key(), paramObj: it.value().toObject()));
1983
1984	const QJsonArray techArray = jsonObject.value(KEY_TECHNIQUES).toArray();
1985	for (const QJsonValue techValue : techArray) {
1986	const QString techName = techValue.toString();
1987	QTechnique *tech = m_techniques.value(key: techName);
1988	if (tech) {
1989	effect->addTechnique(t: tech);
1990	} else {
1991	qCWarning(GLTFImporterLog, "Technique pass %ls missing for effect %ls",
1992	qUtf16PrintableImpl(techName), qUtf16PrintableImpl(id));
1993	}
1994	}
1995
1996	m_effects[id] = effect;
1997	}
1998
1999	void GLTFImporter::processJSONRenderPass(const QString &id, const QJsonObject &jsonObject)
2000	{
2001	QRenderPass *pass = new QRenderPass;
2002	const QJsonObject passFkObj = jsonObject.value(KEY_FILTERKEYS).toObject();
2003	for (auto it = passFkObj.begin(), end = passFkObj.end(); it != end; ++it)
2004	pass->addFilterKey(filterKey: buildFilterKey(key: it.key(), val: it.value()));
2005
2006	const QJsonObject params = jsonObject.value(KEY_PARAMETERS).toObject();
2007	for (auto it = params.begin(), end = params.end(); it != end; ++it)
2008	pass->addParameter(p: buildParameter(key: it.key(), paramObj: it.value().toObject()));
2009
2010	populateRenderStates(pass, states: jsonObject.value(KEY_STATES).toObject());
2011	addProgramToPass(pass, progName: jsonObject.value(KEY_PROGRAM).toString());
2012
2013	renameFromJson(json: jsonObject, object: pass);
2014
2015	m_renderPasses[id] = pass;
2016	}
2017
2018	/*!
2019	Loads raw data from the GLTF file into the buffer.
2020	*/
2021	void GLTFImporter::loadBufferData()
2022	{
2023	for (auto &bufferData : m_bufferDatas) {
2024	if (!bufferData.data) {
2025	bufferData.data = new QByteArray(resolveLocalData(path: bufferData.path));
2026	}
2027	}
2028	}
2029
2030	/*!
2031	Removes all data from the buffer.
2032	*/
2033	void GLTFImporter::unloadBufferData()
2034	{
2035	for (const auto &bufferData : std::as_const(t&: m_bufferDatas)) {
2036	QByteArray *data = bufferData.data;
2037	delete data;
2038	}
2039	}
2040
2041	QByteArray GLTFImporter::resolveLocalData(const QString &path) const
2042	{
2043	QDir d(m_basePath);
2044	Q_ASSERT(d.exists());
2045
2046	// check for embedded data
2047	if (isEmbeddedResource(url: path)) {
2048	const QByteArray base64Data = path.toLatin1().remove(index: 0, len: path.indexOf(s: ",") + 1);
2049	return QByteArray::fromBase64(base64: base64Data);
2050	} else {
2051	const QString absPath = d.absoluteFilePath(fileName: path);
2052	QFile f(absPath);
2053	if (!f.open(flags: QIODevice::ReadOnly))
2054	return QByteArray();
2055	return f.readAll();
2056	}
2057	}
2058
2059	QVariant GLTFImporter::parameterValueFromJSON(int type, const QJsonValue &value) const
2060	{
2061	if (value.isBool()) {
2062	if (type == GL_BOOL)
2063	return QVariant(static_cast<GLboolean>(value.toBool()));
2064	} else if (value.isString()) {
2065	if (type == GL_SAMPLER_2D) {
2066	//Textures are special because we need to do a lookup to return the
2067	//QAbstractTexture
2068	QString textureId = value.toString();
2069	const auto it = m_textures.find(key: textureId);
2070	if (Q_UNLIKELY(it == m_textures.end())) {
2071	qCWarning(GLTFImporterLog, "unknown texture %ls", qUtf16PrintableImpl(textureId));
2072	return QVariant();
2073	} else {
2074	return QVariant::fromValue(value: it.value());
2075	}
2076	}
2077	} else if (value.isDouble()) {
2078	switch (type) {
2079	case GL_BYTE:
2080	return QVariant(static_cast<GLbyte>(value.toInt()));
2081	case GL_UNSIGNED_BYTE:
2082	return QVariant(static_cast<GLubyte>(value.toInt()));
2083	case GL_SHORT:
2084	return QVariant(static_cast<GLshort>(value.toInt()));
2085	case GL_UNSIGNED_SHORT:
2086	return QVariant(static_cast<GLushort>(value.toInt()));
2087	case GL_INT:
2088	return QVariant(static_cast<GLint>(value.toInt()));
2089	case GL_UNSIGNED_INT:
2090	return QVariant(static_cast<GLuint>(value.toInt()));
2091	case GL_FLOAT:
2092	return QVariant(static_cast<GLfloat>(value.toDouble()));
2093	default:
2094	break;
2095	}
2096	} else if (value.isArray()) {
2097
2098	const QJsonArray valueArray = value.toArray();
2099
2100	QVector2D vector2D;
2101	QVector3D vector3D;
2102	QVector4D vector4D;
2103	std::vector<float> dataMat2(4, 0.0f);
2104	std::vector<float> dataMat3(9, 0.0f);
2105
2106	switch (type) {
2107	case GL_BYTE:
2108	return QVariant(static_cast<GLbyte>(valueArray.first().toInt()));
2109	case GL_UNSIGNED_BYTE:
2110	return QVariant(static_cast<GLubyte>(valueArray.first().toInt()));
2111	case GL_SHORT:
2112	return QVariant(static_cast<GLshort>(valueArray.first().toInt()));
2113	case GL_UNSIGNED_SHORT:
2114	return QVariant(static_cast<GLushort>(valueArray.first().toInt()));
2115	case GL_INT:
2116	return QVariant(static_cast<GLint>(valueArray.first().toInt()));
2117	case GL_UNSIGNED_INT:
2118	return QVariant(static_cast<GLuint>(valueArray.first().toInt()));
2119	case GL_FLOAT:
2120	return QVariant(static_cast<GLfloat>(valueArray.first().toDouble()));
2121	case GL_FLOAT_VEC2:
2122	vector2D.setX(static_cast<GLfloat>(valueArray.at(i: 0).toDouble()));
2123	vector2D.setY(static_cast<GLfloat>(valueArray.at(i: 1).toDouble()));
2124	return QVariant(vector2D);
2125	case GL_FLOAT_VEC3:
2126	vector3D.setX(static_cast<GLfloat>(valueArray.at(i: 0).toDouble()));
2127	vector3D.setY(static_cast<GLfloat>(valueArray.at(i: 1).toDouble()));
2128	vector3D.setZ(static_cast<GLfloat>(valueArray.at(i: 2).toDouble()));
2129	return QVariant(vector3D);
2130	case GL_FLOAT_VEC4:
2131	vector4D.setX(static_cast<GLfloat>(valueArray.at(i: 0).toDouble()));
2132	vector4D.setY(static_cast<GLfloat>(valueArray.at(i: 1).toDouble()));
2133	vector4D.setZ(static_cast<GLfloat>(valueArray.at(i: 2).toDouble()));
2134	vector4D.setW(static_cast<GLfloat>(valueArray.at(i: 3).toDouble()));
2135	return QVariant(vector4D);
2136	case GL_INT_VEC2:
2137	vector2D.setX(static_cast<GLint>(valueArray.at(i: 0).toInt()));
2138	vector2D.setY(static_cast<GLint>(valueArray.at(i: 1).toInt()));
2139	return QVariant(vector2D);
2140	case GL_INT_VEC3:
2141	vector3D.setX(static_cast<GLint>(valueArray.at(i: 0).toInt()));
2142	vector3D.setY(static_cast<GLint>(valueArray.at(i: 1).toInt()));
2143	vector3D.setZ(static_cast<GLint>(valueArray.at(i: 2).toInt()));
2144	return QVariant(vector3D);
2145	case GL_INT_VEC4:
2146	vector4D.setX(static_cast<GLint>(valueArray.at(i: 0).toInt()));
2147	vector4D.setY(static_cast<GLint>(valueArray.at(i: 1).toInt()));
2148	vector4D.setZ(static_cast<GLint>(valueArray.at(i: 2).toInt()));
2149	vector4D.setW(static_cast<GLint>(valueArray.at(i: 3).toInt()));
2150	return QVariant(vector4D);
2151	case GL_BOOL:
2152	return QVariant(static_cast<GLboolean>(valueArray.first().toBool()));
2153	case GL_BOOL_VEC2:
2154	vector2D.setX(static_cast<GLboolean>(valueArray.at(i: 0).toBool()));
2155	vector2D.setY(static_cast<GLboolean>(valueArray.at(i: 1).toBool()));
2156	return QVariant(vector2D);
2157	case GL_BOOL_VEC3:
2158	vector3D.setX(static_cast<GLboolean>(valueArray.at(i: 0).toBool()));
2159	vector3D.setY(static_cast<GLboolean>(valueArray.at(i: 1).toBool()));
2160	vector3D.setZ(static_cast<GLboolean>(valueArray.at(i: 2).toBool()));
2161	return QVariant(vector3D);
2162	case GL_BOOL_VEC4:
2163	vector4D.setX(static_cast<GLboolean>(valueArray.at(i: 0).toBool()));
2164	vector4D.setY(static_cast<GLboolean>(valueArray.at(i: 1).toBool()));
2165	vector4D.setZ(static_cast<GLboolean>(valueArray.at(i: 2).toBool()));
2166	vector4D.setW(static_cast<GLboolean>(valueArray.at(i: 3).toBool()));
2167	return QVariant(vector4D);
2168	case GL_FLOAT_MAT2:
2169	//Matrix2x2 is in Row Major ordering (so we need to convert)
2170	dataMat2[0] = static_cast<GLfloat>(valueArray.at(i: 0).toDouble());
2171	dataMat2[1] = static_cast<GLfloat>(valueArray.at(i: 2).toDouble());
2172	dataMat2[2] = static_cast<GLfloat>(valueArray.at(i: 1).toDouble());
2173	dataMat2[3] = static_cast<GLfloat>(valueArray.at(i: 3).toDouble());
2174	return QVariant::fromValue(value: QMatrix2x2(dataMat2.data()));
2175	case GL_FLOAT_MAT3:
2176	//Matrix3x3 is in Row Major ordering (so we need to convert)
2177	dataMat3[0] = static_cast<GLfloat>(valueArray.at(i: 0).toDouble());
2178	dataMat3[1] = static_cast<GLfloat>(valueArray.at(i: 3).toDouble());
2179	dataMat3[2] = static_cast<GLfloat>(valueArray.at(i: 6).toDouble());
2180	dataMat3[3] = static_cast<GLfloat>(valueArray.at(i: 1).toDouble());
2181	dataMat3[4] = static_cast<GLfloat>(valueArray.at(i: 4).toDouble());
2182	dataMat3[5] = static_cast<GLfloat>(valueArray.at(i: 7).toDouble());
2183	dataMat3[6] = static_cast<GLfloat>(valueArray.at(i: 2).toDouble());
2184	dataMat3[7] = static_cast<GLfloat>(valueArray.at(i: 5).toDouble());
2185	dataMat3[8] = static_cast<GLfloat>(valueArray.at(i: 8).toDouble());
2186	return QVariant::fromValue(value: QMatrix3x3(dataMat3.data()));
2187	case GL_FLOAT_MAT4:
2188	//Matrix4x4 is Column Major ordering
2189	return QVariant(QMatrix4x4(static_cast<GLfloat>(valueArray.at(i: 0).toDouble()),
2190	static_cast<GLfloat>(valueArray.at(i: 1).toDouble()),
2191	static_cast<GLfloat>(valueArray.at(i: 2).toDouble()),
2192	static_cast<GLfloat>(valueArray.at(i: 3).toDouble()),
2193	static_cast<GLfloat>(valueArray.at(i: 4).toDouble()),
2194	static_cast<GLfloat>(valueArray.at(i: 5).toDouble()),
2195	static_cast<GLfloat>(valueArray.at(i: 6).toDouble()),
2196	static_cast<GLfloat>(valueArray.at(i: 7).toDouble()),
2197	static_cast<GLfloat>(valueArray.at(i: 8).toDouble()),
2198	static_cast<GLfloat>(valueArray.at(i: 9).toDouble()),
2199	static_cast<GLfloat>(valueArray.at(i: 10).toDouble()),
2200	static_cast<GLfloat>(valueArray.at(i: 11).toDouble()),
2201	static_cast<GLfloat>(valueArray.at(i: 12).toDouble()),
2202	static_cast<GLfloat>(valueArray.at(i: 13).toDouble()),
2203	static_cast<GLfloat>(valueArray.at(i: 14).toDouble()),
2204	static_cast<GLfloat>(valueArray.at(i: 15).toDouble())));
2205	case GL_SAMPLER_2D:
2206	return QVariant(valueArray.at(i: 0).toString());
2207	}
2208	}
2209	return QVariant();
2210	}
2211
2212	QAttribute::VertexBaseType GLTFImporter::accessorTypeFromJSON(int componentType)
2213	{
2214	if (componentType == GL_BYTE) {
2215	return QAttribute::Byte;
2216	} else if (componentType == GL_UNSIGNED_BYTE) {
2217	return QAttribute::UnsignedByte;
2218	} else if (componentType == GL_SHORT) {
2219	return QAttribute::Short;
2220	} else if (componentType == GL_UNSIGNED_SHORT) {
2221	return QAttribute::UnsignedShort;
2222	} else if (componentType == GL_UNSIGNED_INT) {
2223	return QAttribute::UnsignedInt;
2224	} else if (componentType == GL_FLOAT) {
2225	return QAttribute::Float;
2226	}
2227
2228	//There shouldn't be an invalid case here
2229	qCWarning(GLTFImporterLog, "unsupported accessor type %d", componentType);
2230	return QAttribute::Float;
2231	}
2232
2233	uint GLTFImporter::accessorDataSizeFromJson(const QString &type)
2234	{
2235	QString typeName = type.toUpper();
2236	if (typeName == QLatin1String("SCALAR"))
2237	return 1;
2238	if (typeName == QLatin1String("VEC2"))
2239	return 2;
2240	if (typeName == QLatin1String("VEC3"))
2241	return 3;
2242	if (typeName == QLatin1String("VEC4"))
2243	return 4;
2244	if (typeName == QLatin1String("MAT2"))
2245	return 4;
2246	if (typeName == QLatin1String("MAT3"))
2247	return 9;
2248	if (typeName == QLatin1String("MAT4"))
2249	return 16;
2250
2251	return 0;
2252	}
2253
2254	QRenderState *GLTFImporter::buildStateEnable(int state)
2255	{
2256	int type = 0;
2257	//By calling buildState with QJsonValue(), a Render State with
2258	//default values is created.
2259
2260	switch (state) {
2261	case GL_BLEND:
2262	//It doesn't make sense to handle this state alone
2263	return nullptr;
2264	case GL_CULL_FACE:
2265	return buildState(QStringLiteral("cullFace"), value: QJsonValue(), type);
2266	case GL_DEPTH_TEST:
2267	return buildState(QStringLiteral("depthFunc"), value: QJsonValue(), type);
2268	case GL_POLYGON_OFFSET_FILL:
2269	return buildState(QStringLiteral("polygonOffset"), value: QJsonValue(), type);
2270	case GL_SAMPLE_ALPHA_TO_COVERAGE:
2271	return new QAlphaCoverage();
2272	case GL_SCISSOR_TEST:
2273	return buildState(QStringLiteral("scissor"), value: QJsonValue(), type);
2274	case GL_DITHER: // Qt3D Custom
2275	return new QDithering();
2276	case 0x809D: // GL_MULTISAMPLE - Qt3D Custom
2277	return new QMultiSampleAntiAliasing();
2278	case 0x884F: // GL_TEXTURE_CUBE_MAP_SEAMLESS - Qt3D Custom
2279	return new QSeamlessCubemap();
2280	default:
2281	break;
2282	}
2283
2284	qCWarning(GLTFImporterLog, "unsupported render state: %d", state);
2285
2286	return nullptr;
2287	}
2288
2289	QRenderState* GLTFImporter::buildState(const QString& functionName, const QJsonValue &value, int &type)
2290	{
2291	type = -1;
2292	QJsonArray values = value.toArray();
2293
2294	if (functionName == QLatin1String("blendColor")) {
2295	type = GL_BLEND;
2296	//TODO: support render state blendColor
2297	qCWarning(GLTFImporterLog, "unsupported render state: %ls", qUtf16PrintableImpl(functionName));
2298	return nullptr;
2299	}
2300
2301	if (functionName == QLatin1String("blendEquationSeparate")) {
2302	type = GL_BLEND;
2303	//TODO: support settings blendEquation alpha
2304	QBlendEquation *blendEquation = new QBlendEquation;
2305	blendEquation->setBlendFunction((QBlendEquation::BlendFunction)values.at(i: 0).toInt(GL_FUNC_ADD));
2306	return blendEquation;
2307	}
2308
2309	if (functionName == QLatin1String("blendFuncSeparate")) {
2310	type = GL_BLEND;
2311	QBlendEquationArguments *blendArgs = new QBlendEquationArguments;
2312	blendArgs->setSourceRgb((QBlendEquationArguments::Blending)values.at(i: 0).toInt(GL_ONE));
2313	blendArgs->setSourceAlpha((QBlendEquationArguments::Blending)values.at(i: 1).toInt(GL_ONE));
2314	blendArgs->setDestinationRgb((QBlendEquationArguments::Blending)values.at(i: 2).toInt(GL_ZERO));
2315	blendArgs->setDestinationAlpha((QBlendEquationArguments::Blending)values.at(i: 3).toInt(GL_ZERO));
2316	blendArgs->setBufferIndex(values.at(i: 4).toInt(defaultValue: -1));
2317	return blendArgs;
2318	}
2319
2320	if (functionName == QLatin1String("colorMask")) {
2321	QColorMask *colorMask = new QColorMask;
2322	colorMask->setRedMasked(values.at(i: 0).toBool(defaultValue: true));
2323	colorMask->setGreenMasked(values.at(i: 1).toBool(defaultValue: true));
2324	colorMask->setBlueMasked(values.at(i: 2).toBool(defaultValue: true));
2325	colorMask->setAlphaMasked(values.at(i: 3).toBool(defaultValue: true));
2326	return colorMask;
2327	}
2328
2329	if (functionName == QLatin1String("cullFace")) {
2330	type = GL_CULL_FACE;
2331	QCullFace *cullFace = new QCullFace;
2332	cullFace->setMode((QCullFace::CullingMode)values.at(i: 0).toInt(GL_BACK));
2333	return cullFace;
2334	}
2335
2336	if (functionName == QLatin1String("depthFunc")) {
2337	type = GL_DEPTH_TEST;
2338	QDepthTest *depthTest = new QDepthTest;
2339	depthTest->setDepthFunction((QDepthTest::DepthFunction)values.at(i: 0).toInt(GL_LESS));
2340	return depthTest;
2341	}
2342
2343	if (functionName == QLatin1String("depthMask")) {
2344	if (!values.at(i: 0).toBool(defaultValue: true)) {
2345	QNoDepthMask *depthMask = new QNoDepthMask;
2346	return depthMask;
2347	}
2348	return nullptr;
2349	}
2350
2351	if (functionName == QLatin1String("depthRange")) {
2352	type = GL_DEPTH_RANGE;
2353	QDepthRange *depthRange = new QDepthRange;
2354	depthRange->setNearValue(values.at(i: 0).toDouble(defaultValue: 0.0));
2355	depthRange->setFarValue(values.at(i: 1).toDouble(defaultValue: 1.0));
2356	return depthRange;
2357	}
2358
2359	if (functionName == QLatin1String("frontFace")) {
2360	QFrontFace *frontFace = new QFrontFace;
2361	frontFace->setDirection((QFrontFace::WindingDirection)values.at(i: 0).toInt(GL_CCW));
2362	return frontFace;
2363	}
2364
2365	if (functionName == QLatin1String("lineWidth")) {
2366	//TODO: support render state lineWidth
2367	qCWarning(GLTFImporterLog, "unsupported render state: %ls", qUtf16PrintableImpl(functionName));
2368	return nullptr;
2369	}
2370
2371	if (functionName == QLatin1String("polygonOffset")) {
2372	type = GL_POLYGON_OFFSET_FILL;
2373	QPolygonOffset *polygonOffset = new QPolygonOffset;
2374	polygonOffset->setScaleFactor((float)values.at(i: 0).toDouble(defaultValue: 0.0f));
2375	polygonOffset->setDepthSteps((float)values.at(i: 1).toDouble(defaultValue: 0.0f));
2376	return polygonOffset;
2377	}
2378
2379	if (functionName == QLatin1String("scissor")) {
2380	type = GL_SCISSOR_TEST;
2381	QScissorTest *scissorTest = new QScissorTest;
2382	scissorTest->setLeft(values.at(i: 0).toDouble(defaultValue: 0.0f));
2383	scissorTest->setBottom(values.at(i: 1).toDouble(defaultValue: 0.0f));
2384	scissorTest->setWidth(values.at(i: 2).toDouble(defaultValue: 0.0f));
2385	scissorTest->setHeight(values.at(i: 3).toDouble(defaultValue: 0.0f));
2386	return scissorTest;
2387	}
2388
2389	// Qt3D custom functions
2390	if (functionName == QLatin1String("alphaTest")) {
2391	QAlphaTest *args = new QAlphaTest;
2392	args->setAlphaFunction(QAlphaTest::AlphaFunction(values.at(i: 0).toInt()));
2393	args->setReferenceValue(float(values.at(i: 1).toDouble()));
2394	return args;
2395	}
2396
2397	if (functionName == QLatin1String("clipPlane")) {
2398	QClipPlane *args = new QClipPlane;
2399	args->setPlaneIndex(values.at(i: 0).toInt());
2400	args->setNormal(QVector3D(float(values.at(i: 1).toDouble()),
2401	float(values.at(i: 2).toDouble()),
2402	float(values.at(i: 3).toDouble())));
2403	args->setDistance(float(values.at(i: 4).toDouble()));
2404	return args;
2405	}
2406
2407	if (functionName == QLatin1String("pointSize")) {
2408	QPointSize *pointSize = new QPointSize;
2409	pointSize->setSizeMode(QPointSize::SizeMode(values.at(i: 0).toInt(defaultValue: QPointSize::Programmable)));
2410	pointSize->setValue(float(values.at(i: 1).toDouble()));
2411	return pointSize;
2412	}
2413
2414	if (functionName == QLatin1String("stencilMask")) {
2415	QStencilMask *stencilMask = new QStencilMask;
2416	stencilMask->setFrontOutputMask(uint(values.at(i: 0).toInt()));
2417	stencilMask->setBackOutputMask(uint(values.at(i: 1).toInt()));
2418	return stencilMask;
2419	}
2420
2421	if (functionName == QLatin1String("stencilOperation")) {
2422	QStencilOperation *stencilOperation = new QStencilOperation;
2423	stencilOperation->front()->setStencilTestFailureOperation(
2424	QStencilOperationArguments::Operation(values.at(i: 0).toInt(
2425	defaultValue: QStencilOperationArguments::Keep)));
2426	stencilOperation->front()->setDepthTestFailureOperation(
2427	QStencilOperationArguments::Operation(values.at(i: 1).toInt(
2428	defaultValue: QStencilOperationArguments::Keep)));
2429	stencilOperation->front()->setAllTestsPassOperation(
2430	QStencilOperationArguments::Operation(values.at(i: 2).toInt(
2431	defaultValue: QStencilOperationArguments::Keep)));
2432	stencilOperation->back()->setStencilTestFailureOperation(
2433	QStencilOperationArguments::Operation(values.at(i: 3).toInt(
2434	defaultValue: QStencilOperationArguments::Keep)));
2435	stencilOperation->back()->setDepthTestFailureOperation(
2436	QStencilOperationArguments::Operation(values.at(i: 4).toInt(
2437	defaultValue: QStencilOperationArguments::Keep)));
2438	stencilOperation->back()->setAllTestsPassOperation(
2439	QStencilOperationArguments::Operation(values.at(i: 5).toInt(
2440	defaultValue: QStencilOperationArguments::Keep)));
2441	return stencilOperation;
2442	}
2443
2444	if (functionName == QLatin1String("stencilTest")) {
2445	QStencilTest *stencilTest = new QStencilTest;
2446	stencilTest->front()->setComparisonMask(uint(values.at(i: 0).toInt()));
2447	stencilTest->front()->setReferenceValue(values.at(i: 1).toInt());
2448	stencilTest->front()->setStencilFunction(
2449	QStencilTestArguments::StencilFunction(values.at(i: 2).toInt(
2450	defaultValue: QStencilTestArguments::Never)));
2451	stencilTest->back()->setComparisonMask(uint(values.at(i: 3).toInt()));
2452	stencilTest->back()->setReferenceValue(values.at(i: 4).toInt());
2453	stencilTest->back()->setStencilFunction(
2454	QStencilTestArguments::StencilFunction(values.at(i: 5).toInt(
2455	defaultValue: QStencilTestArguments::Never)));
2456	return stencilTest;
2457	}
2458
2459	qCWarning(GLTFImporterLog, "unsupported render state: %ls", qUtf16PrintableImpl(functionName));
2460	return nullptr;
2461	}
2462
2463	QParameter *GLTFImporter::buildParameter(const QString &key, const QJsonObject &paramObj)
2464	{
2465	QParameter *p = new QParameter;
2466	p->setName(key);
2467	QJsonValue value = paramObj.value(KEY_VALUE);
2468
2469	if (!value.isUndefined()) {
2470	int dataType = paramObj.value(KEY_TYPE).toInt();
2471	p->setValue(parameterValueFromJSON(type: dataType, value));
2472	}
2473
2474	return p;
2475	}
2476
2477	void GLTFImporter::populateRenderStates(QRenderPass *pass, const QJsonObject &states)
2478	{
2479	// Process states to enable
2480	const QJsonArray enableStatesArray = states.value(KEY_ENABLE).toArray();
2481	QList<int> enableStates;
2482	for (const QJsonValue enableValue : enableStatesArray)
2483	enableStates.append(t: enableValue.toInt());
2484
2485	// Process the list of state functions
2486	const QJsonObject functions = states.value(KEY_FUNCTIONS).toObject();
2487	for (auto it = functions.begin(), end = functions.end(); it != end; ++it) {
2488	int enableStateType = 0;
2489	QRenderState *renderState = buildState(functionName: it.key(), value: it.value(), type&: enableStateType);
2490	if (renderState != nullptr) {
2491	//Remove the need to set a default state values for enableStateType
2492	enableStates.removeOne(t: enableStateType);
2493	pass->addRenderState(state: renderState);
2494	}
2495	}
2496
2497	// Create render states with default values for any remaining enable states
2498	for (int enableState : std::as_const(t&: enableStates)) {
2499	QRenderState *renderState = buildStateEnable(state: enableState);
2500	if (renderState != nullptr)
2501	pass->addRenderState(state: renderState);
2502	}
2503	}
2504
2505	void GLTFImporter::addProgramToPass(QRenderPass *pass, const QString &progName)
2506	{
2507	const auto progIt = std::as_const(t&: m_programs).find(key: progName);
2508	if (Q_UNLIKELY(progIt == m_programs.cend()))
2509	qCWarning(GLTFImporterLog, "missing program %ls", qUtf16PrintableImpl(progName));
2510	else
2511	pass->setShaderProgram(progIt.value());
2512	}
2513
2514	void GLTFImporter::setTextureSamplerInfo(const QString &id, const QJsonObject &jsonObj, QTexture2D *tex)
2515	{
2516	QJsonObject sampler;
2517	const QJsonValue jsonValue = jsonObj.value(KEY_SAMPLER);
2518	if (jsonValue.isUndefined())
2519	return;
2520
2521	if (m_majorVersion > 1) {
2522	const int samplerId = jsonValue.toInt();
2523	const QJsonArray sArray = m_json.object().value(KEY_SAMPLERS).toArray();
2524	if (Q_UNLIKELY(samplerId >= sArray.count())) {
2525	qCWarning(GLTFImporterLog, "texture %ls references unknown sampler %d",
2526	qUtf16PrintableImpl(id), samplerId);
2527	return;
2528	}
2529	sampler = sArray[samplerId].toObject();
2530	} else {
2531	const QString samplerId = jsonValue.toString();
2532	const QJsonValue samplersDictValue = m_json.object().value(KEY_SAMPLERS).toObject().value(key: samplerId);
2533	if (Q_UNLIKELY(samplersDictValue.isUndefined())) {
2534	qCWarning(GLTFImporterLog, "texture %ls references unknown sampler %ls",
2535	qUtf16PrintableImpl(id), qUtf16PrintableImpl(samplerId));
2536	return;
2537	}
2538	sampler = samplersDictValue.toObject();
2539	}
2540
2541	tex->setWrapMode(QTextureWrapMode(static_cast<QTextureWrapMode::WrapMode>(sampler.value(KEY_WRAP_S).toInt())));
2542	tex->setMinificationFilter(static_cast<QAbstractTexture::Filter>(sampler.value(KEY_MIN_FILTER).toInt()));
2543	if (tex->minificationFilter() == QAbstractTexture::NearestMipMapLinear ||
2544	tex->minificationFilter() == QAbstractTexture::LinearMipMapNearest ||
2545	tex->minificationFilter() == QAbstractTexture::NearestMipMapNearest ||
2546	tex->minificationFilter() == QAbstractTexture::LinearMipMapLinear) {
2547
2548	tex->setGenerateMipMaps(true);
2549	}
2550	tex->setMagnificationFilter(static_cast<QAbstractTexture::Filter>(sampler.value(KEY_MAG_FILTER).toInt()));
2551	}
2552
2553	GLTFRawTextureImage::GLTFRawTextureImage(QNode *parent)
2554	: QAbstractTextureImage(parent)
2555	{
2556	}
2557
2558	QTextureImageDataGeneratorPtr GLTFRawTextureImage::dataGenerator() const
2559	{
2560	return QTextureImageDataGeneratorPtr(new GLTFRawTextureImageFunctor(m_image));
2561	}
2562
2563	void GLTFRawTextureImage::setImage(const QImage &image)
2564	{
2565	if (image != m_image) {
2566	m_image = image;
2567	notifyDataGeneratorChanged();
2568	}
2569	}
2570
2571	GLTFRawTextureImage::GLTFRawTextureImageFunctor::GLTFRawTextureImageFunctor(const QImage &image)
2572	: QTextureImageDataGenerator()
2573	, m_image(image)
2574	{
2575	}
2576
2577	QTextureImageDataPtr GLTFRawTextureImage::GLTFRawTextureImageFunctor::operator()()
2578	{
2579	QTextureImageDataPtr dataPtr = QTextureImageDataPtr::create();
2580	// Note: we assume 4 components per pixel and not compressed for now
2581	dataPtr->setImage(m_image);
2582	return dataPtr;
2583	}
2584
2585	bool GLTFRawTextureImage::GLTFRawTextureImageFunctor::operator ==(const QTextureImageDataGenerator &other) const
2586	{
2587	const GLTFRawTextureImageFunctor *otherFunctor = functor_cast<GLTFRawTextureImageFunctor>(other: &other);
2588	return (otherFunctor != nullptr && otherFunctor->m_image == m_image);
2589	}
2590
2591	} // namespace Qt3DRender
2592
2593	QT_END_NAMESPACE
2594
2595	#include "moc_gltfimporter.cpp"
2596	#include "gltfimporter.moc"
2597