Revision control
++ // Copyright (C) 2021 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++
++ #include "assimpimporter.h"
++
++ #include <assimputils.h>
++
++ #include <QtCore/qurl.h>
++ #include <QtCore/qbytearrayalgorithms.h>
++ #include <QtGui/QQuaternion>
++ #include <QtQml/QQmlFile>
++
++ #include <QtQuick3DAssetImport/private/qssgassetimporterfactory_p.h>
++ #include <QtQuick3DAssetImport/private/qssgassetimporter_p.h>
++ #include <QtQuick3DAssetUtils/private/qssgscenedesc_p.h>
++ #include <QtQuick3DAssetUtils/private/qssgsceneedit_p.h>
++ #include <QtQuick3DAssetUtils/private/qssgqmlutilities_p.h>
++
++ #include <QtQuick3DUtils/private/qssgutils_p.h>
++
++ // ASSIMP INC
++ #include <assimp/Importer.hpp>
++ #include <assimp/scene.h>
++ #include <assimp/Logger.hpp>
++ #include <assimp/DefaultLogger.hpp>
++ #include <assimp/postprocess.h>
++ #include <assimp/material.h>
++ #include <assimp/GltfMaterial.h>
++ #include <assimp/importerdesc.h>
++ #include <assimp/IOSystem.hpp>
++ #include <assimp/IOStream.hpp>
++
++ // ASSIMP INC
++
++ QT_BEGIN_NAMESPACE
++
++ //////////////////////// ASSIMP IMP
++
++ #define AI_GLTF_FILTER_NEAREST 0x2600
++ #define AI_GLTF_FILTER_LINEAR 0x2601
++ #define AI_GLTF_FILTER_NEAREST_MIPMAP_NEAREST 0x2700
++ #define AI_GLTF_FILTER_LINEAR_MIPMAP_NEAREST 0x2701
++ #define AI_GLTF_FILTER_NEAREST_MIPMAP_LINEAR 0x2702
++ #define AI_GLTF_FILTER_LINEAR_MIPMAP_LINEAR 0x2703
++
++ Q_REQUIRED_RESULT static inline QColor aiColorToQColor(const aiColor3D &color)
++ {
++ return QColor::fromRgbF(color.r, color.g, color.b, 1.0f);
++ }
++
++ Q_REQUIRED_RESULT static inline QColor aiColorToQColor(const aiColor4D &color)
++ {
++ return QColor::fromRgbF(color.r, color.g, color.b, color.a);
++ }
++
++ static QByteArray fromAiString(const aiString &string)
++ {
++ const qsizetype length = string.length;
++ return QByteArray(string.data, length);
++ }
++
++ struct NodeInfo
++ {
++ using Type = QSSGSceneDesc::Node::Type;
++ size_t index;
++ Type type;
++ };
++
++ Q_DECLARE_TYPEINFO(NodeInfo, Q_PRIMITIVE_TYPE);
++
++ using NodeMap = QHash<const aiNode *, NodeInfo>;
++
++ using AnimationNodeMap = QHash<QByteArray, QSSGSceneDesc::Node *>;
++
++ [[nodiscard]] static inline bool isEqual(const aiUVTransform &a, const aiUVTransform &b)
++ {
++ return (a.mTranslation == b.mTranslation && a.mScaling == b.mScaling && a.mRotation == b.mRotation);
++ };
++
++ struct TextureInfo
++ {
++ aiTextureMapMode modes[3] {};
++ aiTextureMapping mapping = aiTextureMapping::aiTextureMapping_UV;
++ unsigned int minFilter { AI_GLTF_FILTER_LINEAR };
++ unsigned int magFilter { AI_GLTF_FILTER_LINEAR };
++ uint uvIndex { 0 };
++ aiUVTransform transform;
++ };
++
++ bool operator==(const TextureInfo &a, const TextureInfo &b)
++ {
++ return (a.mapping == b.mapping)
++ && (std::memcmp(a.modes, b.modes, sizeof(a.modes)) == 0)
++ && (a.minFilter == b.minFilter)
++ && (a.magFilter == b.magFilter)
++ && (a.uvIndex == b.uvIndex)
++ && isEqual(a.transform, b.transform);
++ }
++
++ struct TextureEntry
++ {
++ QByteArray name;
++ TextureInfo info;
++ QSSGSceneDesc::Texture *texture = nullptr;
++ };
++
++ size_t qHash(const TextureEntry &key, size_t seed)
++ {
++ static_assert(std::is_same_v<decltype(key.info.transform), aiUVTransform>, "Unexpected type");
++ const auto infoKey = quintptr(key.info.mapping)
++ ^ (quintptr(key.info.modes[0]) ^ quintptr(key.info.modes[1]) ^ quintptr(key.info.modes[2]))
++ ^ quintptr(key.info.minFilter ^ key.info.magFilter)
++ ^ quintptr(key.info.uvIndex)
++ ^ qHashBits(&key.info.transform, sizeof(aiUVTransform), seed);
++
++ return qHash(key.name, seed) ^ infoKey;
++ }
++
++ bool operator==(const TextureEntry &a, const TextureEntry &b)
++ {
++ return (a.name == b.name) && (a.info == b.info);
++ }
++
++ struct SceneInfo
++ {
++ struct Options
++ {
++ bool gltfMode = false;
++ bool fbxMode = false;
++ bool binaryKeyframes = false;
++ bool forceMipMapGeneration = false;
++ bool useFloatJointIndices = false;
++ bool designStudioWorkarounds = false;
++
++ float globalScaleValue = 1.0;
++
++ bool generateMeshLODs = false;
++ float lodNormalMergeAngle = 60.0;
++ float lodNormalSplitAngle = 25.0;
++ };
++
++ using MaterialMap = QVarLengthArray<QPair<const aiMaterial *, QSSGSceneDesc::Material *>>;
++ using MeshMap = QVarLengthArray<QPair<const aiMesh *, QSSGSceneDesc::Mesh *>>;
++ using EmbeddedTextureMap = QVarLengthArray<QSSGSceneDesc::TextureData *>;
++ using TextureMap = QSet<TextureEntry>;
++
++ struct skinData {
++ aiBone **mBones;
++ unsigned int mNumBones;
++ QSSGSceneDesc::Skin *node;
++ };
++ using SkinMap = QVarLengthArray<skinData>;
++ using Mesh2SkinMap = QVarLengthArray<qint16>;
++
++ const aiScene &scene;
++ MaterialMap &materialMap;
++ MeshMap &meshMap;
++ EmbeddedTextureMap &embeddedTextureMap;
++ TextureMap &textureMap;
++ SkinMap &skinMap;
++ Mesh2SkinMap &mesh2skin;
++ QDir workingDir;
++ Options opt;
++ };
++
++ class ResourceIOStream : public Assimp::IOStream
++ {
++ public:
++ ResourceIOStream(const char *pFile, const char *pMode);
++
++ // IOStream interface
++ size_t Read(void *pvBuffer, size_t pSize, size_t pCount) override;
++ size_t Write(const void *pvBuffer, size_t pSize, size_t pCount) override;
++ aiReturn Seek(size_t pOffset, aiOrigin pOrigin) override;
++ size_t Tell() const override;
++ size_t FileSize() const override;
++ void Flush() override;
++
++ private:
++ QFile file;
++ };
++
++ ResourceIOStream::ResourceIOStream(const char *pFile, const char *pMode) : file(QString::fromStdString(pFile))
++ {
++ QByteArray mode = QByteArray(pMode);
++ QFile::OpenMode openMode = QFile::NotOpen;
++ if (mode.startsWith("r"))
++ openMode |= QFile::ReadOnly;
++ else if (mode.startsWith("w"))
++ openMode |= QFile::WriteOnly;
++ if (mode.endsWith("t"))
++ openMode |= QFile::Text;
++ if (!file.open(openMode)) {
++ qWarning("Failed to open file %s: %s",
++ qPrintable(file.fileName()), qPrintable(file.errorString()));
++ }
++ }
++
++ size_t ResourceIOStream::Read(void *pvBuffer, size_t pSize, size_t pCount)
++ {
++ size_t ret = 0;
++ auto buffer = static_cast<char *>(pvBuffer);
++ for (ret = 0; ret < pCount; ret++) {
++ size_t read = file.read(buffer, pSize);
++ if (read != pSize)
++ return ret;
++ buffer += read;
++ }
++ return ret;
++ }
++
++ size_t ResourceIOStream::Write(const void *pvBuffer, size_t pSize, size_t pCount)
++ {
++ Q_UNUSED(pvBuffer);
++ Q_UNUSED(pSize);
++ Q_UNUSED(pCount);
++ Q_UNIMPLEMENTED();
++ return 0;
++ }
++
++ aiReturn ResourceIOStream::Seek(size_t pOffset, aiOrigin pOrigin)
++ {
++ switch (pOrigin) {
++ case aiOrigin_SET:
++ file.seek(pOffset);
++ break;
++ case aiOrigin_CUR:
++ file.seek(file.pos() + pOffset);
++ break;
++ case aiOrigin_END:
++ file.seek(file.size() + pOffset);
++ break;
++ default:
++ return aiReturn_FAILURE;
++ }
++ return aiReturn_SUCCESS;
++ }
++
++ size_t ResourceIOStream::Tell() const
++ {
++ return file.pos();
++ }
++
++ size_t ResourceIOStream::FileSize() const
++ {
++ return file.size();
++ }
++
++ void ResourceIOStream::Flush()
++ {
++ }
++
++ class ResourceIOSystem : public Assimp::IOSystem
++ {
++ public:
++ ResourceIOSystem();
++ // IOSystem interface
++ bool Exists(const char *pFile) const override;
++ char getOsSeparator() const override;
++ Assimp::IOStream *Open(const char *pFile, const char *pMode) override;
++ void Close(Assimp::IOStream *pFile) override;
++ };
++
++ ResourceIOSystem::ResourceIOSystem() : Assimp::IOSystem() { }
++
++ bool ResourceIOSystem::Exists(const char *pFile) const
++ {
++ return QFile::exists(QString::fromStdString(pFile));
++ }
++
++ char ResourceIOSystem::getOsSeparator() const
++ {
++ return QDir::separator().toLatin1();
++ }
++
++ Assimp::IOStream *ResourceIOSystem::Open(const char *pFile, const char *pMode)
++ {
++ return new ResourceIOStream(pFile, pMode);
++ }
++
++ void ResourceIOSystem::Close(Assimp::IOStream *pFile)
++ {
++ delete pFile;
++ }
++
++ static void setNodeProperties(QSSGSceneDesc::Node &target,
++ const aiNode &source,
++ const SceneInfo &sceneInfo,
++ aiMatrix4x4 *transformCorrection)
++ {
++ // objectName
++ if (target.name.isNull()) {
++ if (source.mName.length > 0)
++ target.name = fromAiString(source.mName);
++ else
++ target.name = QSSGQmlUtilities::getQmlElementName(target);
++ }
++
++ // Apply correction if necessary
++ aiMatrix4x4 transformMatrix;
++ if (transformCorrection)
++ transformMatrix = source.mTransformation * *transformCorrection;
++ else
++ transformMatrix = source.mTransformation;
++
++ // Decompose Transform Matrix to get properties
++ aiVector3D scaling;
++ aiQuaternion rotation;
++ aiVector3D translation;
++ transformMatrix.Decompose(scaling, rotation, translation);
++
++ // translate
++ if (!sceneInfo.opt.designStudioWorkarounds) {
++ QSSGSceneDesc::setProperty(target, "position", &QQuick3DNode::setPosition, QVector3D { translation.x, translation.y, translation.z });
++ } else {
++ QSSGSceneDesc::setProperty(target, "x", &QQuick3DNode::setX, translation.x);
++ QSSGSceneDesc::setProperty(target, "y", &QQuick3DNode::setY, translation.y);
++ QSSGSceneDesc::setProperty(target, "z", &QQuick3DNode::setZ, translation.z);
++ }
++
++
++ // rotation
++ const QQuaternion rot(rotation.w, rotation.x, rotation.y, rotation.z);
++ QSSGSceneDesc::setProperty(target, "rotation", &QQuick3DNode::setRotation, rot);
++
++ // scale
++ QSSGSceneDesc::setProperty(target, "scale", &QQuick3DNode::setScale, QVector3D { scaling.x, scaling.y, scaling.z });
++ // pivot
++
++ // opacity
++
++ // visible
++ }
++
++ static void setTextureProperties(QSSGSceneDesc::Texture &target, const TextureInfo &texInfo, const SceneInfo &sceneInfo)
++ {
++ const bool forceMipMapGeneration = sceneInfo.opt.forceMipMapGeneration;
++
++ if (texInfo.uvIndex > 0) {
++ // Quick3D supports 2 tex coords.
++ // According to gltf's khronos default implementation,
++ // the index will be selected to the nearest one.
++ QSSGSceneDesc::setProperty(target, "indexUV", &QQuick3DTexture::setIndexUV, 1);
++ }
++
++ // mapping
++ if (texInfo.mapping == aiTextureMapping_UV) {
++ // So we should be able to always hit this case by passing the right flags
++ // at import.
++ QSSGSceneDesc::setProperty(target, "mappingMode", &QQuick3DTexture::setMappingMode, QQuick3DTexture::MappingMode::UV);
++ // It would be possible to use another channel than UV0 to map texture data
++ // but for now we force everything to use UV0
++ //int uvSource;
++ //material->Get(AI_MATKEY_UVWSRC(textureType, index), uvSource);
++ } // else (not supported)
++
++ static const auto asQtTilingMode = [](aiTextureMapMode mode) {
++ switch (mode) {
++ case aiTextureMapMode_Wrap:
++ return QQuick3DTexture::TilingMode::Repeat;
++ case aiTextureMapMode_Clamp:
++ return QQuick3DTexture::TilingMode::ClampToEdge;
++ case aiTextureMapMode_Mirror:
++ return QQuick3DTexture::TilingMode::MirroredRepeat;
++ default:
++ break;
++ }
++
++ return QQuick3DTexture::TilingMode::Repeat;
++ };
++
++ // mapping mode U
++ QSSGSceneDesc::setProperty(target, "tilingModeHorizontal", &QQuick3DTexture::setHorizontalTiling, asQtTilingMode(texInfo.modes[0]));
++
++ // mapping mode V
++ QSSGSceneDesc::setProperty(target, "tilingModeVertical", &QQuick3DTexture::setVerticalTiling, asQtTilingMode(texInfo.modes[1]));
++
++ const bool applyUvTransform = !isEqual(texInfo.transform, aiUVTransform());
++ if (applyUvTransform) {
++ // UV origins -
++ // glTF: 0, 1 (top left of texture)
++ // Assimp, Collada?, FBX?: 0.5, 0.5
++ // Quick3D: 0, 0 (bottom left of texture)
++ // Assimp already tries to fix it but it's not correct.
++ // So, we restore original values and then use pivot
++ const auto &transform = texInfo.transform;
++ float rotation = -transform.mRotation;
++ float rotationUV = qRadiansToDegrees(rotation);
++ float posU = transform.mTranslation.x;
++ float posV = transform.mTranslation.y;
++ if (sceneInfo.opt.gltfMode) {
++ const float rcos = std::cos(rotation);
++ const float rsin = std::sin(rotation);
++ posU -= 0.5f * transform.mScaling.x * (-rcos + rsin + 1.0f);
++ posV -= (0.5f * transform.mScaling.y * (rcos + rsin - 1.0f) + 1.0f - transform.mScaling.y);
++ QSSGSceneDesc::setProperty(target, "pivotV", &QQuick3DTexture::setPivotV, 1.0f);
++ } else {
++ QSSGSceneDesc::setProperty(target, "pivotU", &QQuick3DTexture::setPivotV, 0.5f);
++ QSSGSceneDesc::setProperty(target, "pivotV", &QQuick3DTexture::setPivotV, 0.5f);
++ }
++
++ QSSGSceneDesc::setProperty(target, "positionU", &QQuick3DTexture::setPositionU, posU);
++ QSSGSceneDesc::setProperty(target, "positionV", &QQuick3DTexture::setPositionV, posV);
++ QSSGSceneDesc::setProperty(target, "rotationUV", &QQuick3DTexture::setRotationUV, rotationUV);
++ QSSGSceneDesc::setProperty(target, "scaleU", &QQuick3DTexture::setScaleU, transform.mScaling.x);
++ QSSGSceneDesc::setProperty(target, "scaleV", &QQuick3DTexture::setScaleV, transform.mScaling.y);
++ }
++ // We don't make use of the data here, but there are additional flags
++ // available for example the usage of the alpha channel
++ // texture flags
++ //int textureFlags;
++ //material->Get(AI_MATKEY_TEXFLAGS(textureType, index), textureFlags);
++
++ // Always generate and use mipmaps for imported assets
++ bool generateMipMaps = forceMipMapGeneration;
++ auto mipFilter = forceMipMapGeneration ? QQuick3DTexture::Filter::Linear : QQuick3DTexture::Filter::None;
++
++ // magFilter
++ auto filter = (texInfo.magFilter == AI_GLTF_FILTER_NEAREST) ? QQuick3DTexture::Filter::Nearest : QQuick3DTexture::Filter::Linear;
++ QSSGSceneDesc::setProperty(target, "magFilter", &QQuick3DTexture::setMagFilter, filter);
++
++ // minFilter
++ if (texInfo.minFilter == AI_GLTF_FILTER_NEAREST) {
++ filter = QQuick3DTexture::Filter::Nearest;
++ } else if (texInfo.minFilter == AI_GLTF_FILTER_LINEAR) {
++ filter = QQuick3DTexture::Filter::Linear;
++ } else if (texInfo.minFilter == AI_GLTF_FILTER_NEAREST_MIPMAP_NEAREST) {
++ filter = QQuick3DTexture::Filter::Nearest;
++ mipFilter = QQuick3DTexture::Filter::Nearest;
++ } else if (texInfo.minFilter == AI_GLTF_FILTER_LINEAR_MIPMAP_NEAREST) {
++ filter = QQuick3DTexture::Filter::Linear;
++ mipFilter = QQuick3DTexture::Filter::Nearest;
++ } else if (texInfo.minFilter == AI_GLTF_FILTER_NEAREST_MIPMAP_LINEAR) {
++ filter = QQuick3DTexture::Filter::Nearest;
++ mipFilter = QQuick3DTexture::Filter::Linear;
++ } else if (texInfo.minFilter == AI_GLTF_FILTER_LINEAR_MIPMAP_LINEAR) {
++ filter = QQuick3DTexture::Filter::Linear;
++ mipFilter = QQuick3DTexture::Filter::Linear;
++ }
++ QSSGSceneDesc::setProperty(target, "minFilter", &QQuick3DTexture::setMinFilter, filter);
++
++ // mipFilter
++ generateMipMaps = (mipFilter != QQuick3DTexture::Filter::None);
++
++ if (generateMipMaps) {
++ QSSGSceneDesc::setProperty(target, "generateMipmaps", &QQuick3DTexture::setGenerateMipmaps, true);
++ QSSGSceneDesc::setProperty(target, "mipFilter", &QQuick3DTexture::setMipFilter, mipFilter);
++ }
++ }
++
++ static void setMaterialProperties(QSSGSceneDesc::Material &target, const aiMaterial &source, const SceneInfo &sceneInfo, QSSGSceneDesc::Material::RuntimeType type)
++ {
++ if (target.name.isNull()) {
++ aiString materialName = source.GetName();
++ if (materialName.length > 0)
++ target.name = fromAiString(materialName);
++ else
++ target.name = QSSGQmlUtilities::getQmlElementName(target);
++ }
++
++ const auto createTextureNode = [&sceneInfo, &target](const aiMaterial &material, aiTextureType textureType, unsigned int index) {
++ const auto &srcScene = sceneInfo.scene;
++ QSSGSceneDesc::Texture *tex = nullptr;
++ aiString texturePath;
++ TextureInfo texInfo;
++
++ if (material.GetTexture(textureType, index, &texturePath, &texInfo.mapping, &texInfo.uvIndex, nullptr, nullptr, texInfo.modes) == aiReturn_SUCCESS) {
++ if (texturePath.length > 0) {
++ aiUVTransform transform;
++ if (material.Get(AI_MATKEY_UVTRANSFORM(textureType, index), transform) == aiReturn_SUCCESS)
++ texInfo.transform = transform;
++
++ material.Get(AI_MATKEY_UVWSRC(textureType, index), texInfo.uvIndex);
++ material.Get(AI_MATKEY_GLTF_MAPPINGFILTER_MIN(textureType, index), texInfo.minFilter);
++ material.Get(AI_MATKEY_GLTF_MAPPINGFILTER_MAG(textureType, index), texInfo.magFilter);
++
++ auto &textureMap = sceneInfo.textureMap;
++
++ QByteArray texName = QByteArray(texturePath.C_Str(), texturePath.length);
++ // Check if we already processed this texture
++ const auto it = textureMap.constFind(TextureEntry{texName, texInfo});
++ if (it != textureMap.cend()) {
++ Q_ASSERT(it->texture);
++ tex = it->texture;
++ } else {
++ // Two types, externally referenced or embedded
++ // Use the source file name as the identifier, since that will hopefully be fairly stable for re-import.
++ tex = new QSSGSceneDesc::Texture(QSSGSceneDesc::Texture::RuntimeType::Image2D, texName);
++ textureMap.insert(TextureEntry{fromAiString(texturePath), texInfo, tex});
++ QSSGSceneDesc::addNode(target, *tex);
++ setTextureProperties(*tex, texInfo, sceneInfo); // both
++
++ auto aEmbeddedTex = srcScene.GetEmbeddedTextureAndIndex(texturePath.C_Str());
++ const auto &embeddedTexId = aEmbeddedTex.second;
++ if (embeddedTexId > -1) {
++ QSSGSceneDesc::TextureData *textureData = nullptr;
++ auto &embeddedTextures = sceneInfo.embeddedTextureMap;
++ textureData = embeddedTextures[embeddedTexId];
++ if (!textureData) {
++ const auto *sourceTexture = aEmbeddedTex.first;
++ Q_ASSERT(sourceTexture->pcData);
++ // Two cases of embedded textures, uncompress and compressed.
++ const bool isCompressed = (sourceTexture->mHeight == 0);
++
++ // For compressed textures this is the size of the image buffer (in bytes)
++ const qsizetype asize = (isCompressed) ? sourceTexture->mWidth : (sourceTexture->mHeight * sourceTexture->mWidth) * sizeof(aiTexel);
++ const QSize size = (!isCompressed) ? QSize(int(sourceTexture->mWidth), int(sourceTexture->mHeight)) : QSize();
++ QByteArray imageData { reinterpret_cast<const char *>(sourceTexture->pcData), asize };
++ const auto format = (isCompressed) ? QByteArray(sourceTexture->achFormatHint) : QByteArrayLiteral("rgba8888");
++ const quint8 flags = isCompressed ? quint8(QSSGSceneDesc::TextureData::Flags::Compressed) : 0;
++ textureData = new QSSGSceneDesc::TextureData(imageData, size, format, flags);
++ QSSGSceneDesc::addNode(*tex, *textureData);
++ embeddedTextures[embeddedTexId] = textureData;
++ }
++
++ if (textureData)
++ QSSGSceneDesc::setProperty(*tex, "textureData", &QQuick3DTexture::setTextureData, textureData);
++ } else {
++ auto relativePath = QString::fromUtf8(texturePath.C_Str());
++ // Replace Windows separator to Unix separator
++ // so that assets including Windows relative path can be converted on Unix.
++ relativePath.replace("\\","/");
++ const auto path = sceneInfo.workingDir.absoluteFilePath(relativePath);
++ QSSGSceneDesc::setProperty(*tex, "source", &QQuick3DTexture::setSource, QUrl{ path });
++ }
++ }
++ }
++ }
++
++ return tex;
++ };
++
++ aiReturn result;
++
++ if (type == QSSGSceneDesc::Material::RuntimeType::PrincipledMaterial) {
++ {
++ aiColor4D baseColorFactor;
++ result = source.Get(AI_MATKEY_BASE_COLOR, baseColorFactor);
++ if (result == aiReturn_SUCCESS) {
++ // Some special handling required since baseColorFactor's are stored as linear factors and need to be converted for Qt Quick
++ const QColor sRGBBaseColorFactor = QSSGUtils::color::linearTosRGB(QVector4D(baseColorFactor.r, baseColorFactor.g, baseColorFactor.b, baseColorFactor.a));
++ QSSGSceneDesc::setProperty(target, "baseColor", &QQuick3DPrincipledMaterial::setBaseColor, sRGBBaseColorFactor);
++ } else {
++ // Also try diffuse color as a fallback
++ aiColor3D diffuseColor;
++ result = source.Get(AI_MATKEY_COLOR_DIFFUSE, diffuseColor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "baseColor", &QQuick3DPrincipledMaterial::setBaseColor, aiColorToQColor(diffuseColor));
++ }
++ }
++
++ if (auto baseColorTexture = createTextureNode(source, AI_MATKEY_BASE_COLOR_TEXTURE)) {
++ QSSGSceneDesc::setProperty(target, "baseColorMap", &QQuick3DPrincipledMaterial::setBaseColorMap, baseColorTexture);
++ QSSGSceneDesc::setProperty(target, "opacityChannel", &QQuick3DPrincipledMaterial::setOpacityChannel, QQuick3DPrincipledMaterial::TextureChannelMapping::A);
++ } else if (auto diffuseMapTexture = createTextureNode(source, aiTextureType_DIFFUSE, 0)) {
++ // Also try to legacy diffuse texture as an alternative
++ QSSGSceneDesc::setProperty(target, "baseColorMap", &QQuick3DPrincipledMaterial::setBaseColorMap, diffuseMapTexture);
++ }
++
++ if (auto metalicRoughnessTexture = createTextureNode(source, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE)) {
++ QSSGSceneDesc::setProperty(target, "metalnessMap", &QQuick3DPrincipledMaterial::setMetalnessMap, metalicRoughnessTexture);
++ QSSGSceneDesc::setProperty(target, "metalnessChannel", &QQuick3DPrincipledMaterial::setMetalnessChannel, QQuick3DPrincipledMaterial::TextureChannelMapping::B);
++ QSSGSceneDesc::setProperty(target, "roughnessMap", &QQuick3DPrincipledMaterial::setRoughnessMap, metalicRoughnessTexture);
++ QSSGSceneDesc::setProperty(target, "roughnessChannel", &QQuick3DPrincipledMaterial::setRoughnessChannel, QQuick3DPrincipledMaterial::TextureChannelMapping::G);
++ }
++
++ {
++ ai_real metallicFactor;
++ result = source.Get(AI_MATKEY_METALLIC_FACTOR, metallicFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "metalness", &QQuick3DPrincipledMaterial::setMetalness, float(metallicFactor));
++ }
++
++ {
++ ai_real roughnessFactor;
++ result = source.Get(AI_MATKEY_ROUGHNESS_FACTOR, roughnessFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "roughness", &QQuick3DPrincipledMaterial::setRoughness, float(roughnessFactor));
++ }
++
++ if (auto normalTexture = createTextureNode(source, aiTextureType_NORMALS, 0)) {
++ QSSGSceneDesc::setProperty(target, "normalMap", &QQuick3DPrincipledMaterial::setNormalMap, normalTexture);
++ {
++ ai_real normalScale;
++ result = source.Get(AI_MATKEY_GLTF_TEXTURE_SCALE(aiTextureType_NORMALS, 0), normalScale);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "normalStrength", &QQuick3DPrincipledMaterial::setNormalStrength, float(normalScale));
++ }
++ }
++
++ // Occlusion Textures are not implimented (yet)
++ if (auto occlusionTexture = createTextureNode(source, aiTextureType_LIGHTMAP, 0)) {
++ QSSGSceneDesc::setProperty(target, "occlusionMap", &QQuick3DPrincipledMaterial::setOcclusionMap, occlusionTexture);
++ QSSGSceneDesc::setProperty(target, "occlusionChannel", &QQuick3DPrincipledMaterial::setOcclusionChannel, QQuick3DPrincipledMaterial::TextureChannelMapping::R);
++ {
++ ai_real occlusionAmount;
++ result = source.Get(AI_MATKEY_GLTF_TEXTURE_STRENGTH(aiTextureType_LIGHTMAP, 0), occlusionAmount);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "occlusionAmount", &QQuick3DPrincipledMaterial::setOcclusionAmount, float(occlusionAmount));
++ }
++ }
++
++ if (auto emissiveTexture = createTextureNode(source, aiTextureType_EMISSIVE, 0))
++ QSSGSceneDesc::setProperty(target, "emissiveMap", &QQuick3DPrincipledMaterial::setEmissiveMap, emissiveTexture);
++
++ {
++ aiColor3D emissiveColorFactor;
++ result = source.Get(AI_MATKEY_COLOR_EMISSIVE, emissiveColorFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "emissiveFactor", &QQuick3DPrincipledMaterial::setEmissiveFactor, QVector3D { emissiveColorFactor.r, emissiveColorFactor.g, emissiveColorFactor.b });
++ }
++
++ {
++ bool isDoubleSided;
++ result = source.Get(AI_MATKEY_TWOSIDED, isDoubleSided);
++ if (result == aiReturn_SUCCESS && isDoubleSided)
++ QSSGSceneDesc::setProperty(target, "cullMode", &QQuick3DPrincipledMaterial::setCullMode, QQuick3DPrincipledMaterial::CullMode::NoCulling);
++ }
++
++ {
++ aiString alphaMode;
++ result = source.Get(AI_MATKEY_GLTF_ALPHAMODE, alphaMode);
++ if (result == aiReturn_SUCCESS) {
++ auto mode = QQuick3DPrincipledMaterial::AlphaMode::Default;
++ if (QByteArrayView(alphaMode.C_Str()) == "OPAQUE")
++ mode = QQuick3DPrincipledMaterial::AlphaMode::Opaque;
++ else if (QByteArrayView(alphaMode.C_Str()) == "MASK")
++ mode = QQuick3DPrincipledMaterial::AlphaMode::Mask;
++ else if (QByteArrayView(alphaMode.C_Str()) == "BLEND")
++ mode = QQuick3DPrincipledMaterial::AlphaMode::Blend;
++
++ if (mode != QQuick3DPrincipledMaterial::AlphaMode::Default) {
++ QSSGSceneDesc::setProperty(target, "alphaMode", &QQuick3DPrincipledMaterial::setAlphaMode, mode);
++ // If the mode is mask, we also need to force OpaquePrePassDepthDraw mode
++ if (mode == QQuick3DPrincipledMaterial::AlphaMode::Mask)
++ QSSGSceneDesc::setProperty(target, "depthDrawMode", &QQuick3DPrincipledMaterial::setDepthDrawMode, QQuick3DMaterial::OpaquePrePassDepthDraw);
++ }
++ }
++ }
++
++ {
++ ai_real alphaCutoff;
++ result = source.Get(AI_MATKEY_GLTF_ALPHACUTOFF, alphaCutoff);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "alphaCutoff", &QQuick3DPrincipledMaterial::setAlphaCutoff, float(alphaCutoff));
++ }
++
++ {
++ int shadingModel = 0;
++ result = source.Get(AI_MATKEY_SHADING_MODEL, shadingModel);
++ if (result == aiReturn_SUCCESS && shadingModel == aiShadingMode_Unlit)
++ QSSGSceneDesc::setProperty(target, "lighting", &QQuick3DPrincipledMaterial::setLighting, QQuick3DPrincipledMaterial::Lighting::NoLighting);
++ }
++
++
++ {
++ // Clearcoat Properties (KHR_materials_clearcoat)
++ // factor
++ {
++ ai_real clearcoatFactor = 0.0f;
++ result = source.Get(AI_MATKEY_CLEARCOAT_FACTOR, clearcoatFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "clearcoatAmount",
++ &QQuick3DPrincipledMaterial::setClearcoatAmount,
++ float(clearcoatFactor));
++ }
++
++ // roughness
++ {
++ ai_real clearcoatRoughnessFactor = 0.0f;
++ result = source.Get(AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR, clearcoatRoughnessFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "clearcoatRoughnessAmount",
++ &QQuick3DPrincipledMaterial::setClearcoatRoughnessAmount,
++ float(clearcoatRoughnessFactor));
++ }
++
++ // texture
++ if (auto clearcoatTexture = createTextureNode(source, AI_MATKEY_CLEARCOAT_TEXTURE))
++ QSSGSceneDesc::setProperty(target, "clearcoatMap", &QQuick3DPrincipledMaterial::setClearcoatMap, clearcoatTexture);
++
++ // roughness texture
++ if (auto clearcoatRoughnessTexture = createTextureNode(source, AI_MATKEY_CLEARCOAT_ROUGHNESS_TEXTURE))
++ QSSGSceneDesc::setProperty(target,
++ "clearcoatRoughnessMap",
++ &QQuick3DPrincipledMaterial::setClearcoatRoughnessMap,
++ clearcoatRoughnessTexture);
++
++ // normal texture
++ if (auto clearcoatNormalTexture = createTextureNode(source, AI_MATKEY_CLEARCOAT_NORMAL_TEXTURE))
++ QSSGSceneDesc::setProperty(target, "clearcoatNormalMap", &QQuick3DPrincipledMaterial::setClearcoatNormalMap, clearcoatNormalTexture);
++ }
++
++ {
++ // Transmission Properties (KHR_materials_transmission)
++ // factor
++ {
++ ai_real transmissionFactor = 0.0f;
++ result = source.Get(AI_MATKEY_TRANSMISSION_FACTOR, transmissionFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "transmissionFactor",
++ &QQuick3DPrincipledMaterial::setTransmissionFactor,
++ float(transmissionFactor));
++ }
++
++ // texture
++ {
++ if (auto transmissionImage = createTextureNode(source, AI_MATKEY_TRANSMISSION_TEXTURE))
++ QSSGSceneDesc::setProperty(target,
++ "transmissionMap",
++ &QQuick3DPrincipledMaterial::setTransmissionMap,
++ transmissionImage);
++ }
++
++ }
++
++ {
++ // Volume Properties (KHR_materials_volume) [only used with transmission]
++ // thicknessFactor
++ {
++ ai_real thicknessFactor = 0.0f;
++ result = source.Get(AI_MATKEY_VOLUME_THICKNESS_FACTOR, thicknessFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "thicknessFactor", &QQuick3DPrincipledMaterial::setThicknessFactor, float(thicknessFactor));
++ }
++
++ // thicknessMap
++ {
++ if (auto thicknessImage = createTextureNode(source, AI_MATKEY_VOLUME_THICKNESS_TEXTURE))
++ QSSGSceneDesc::setProperty(target, "thicknessMap", &QQuick3DPrincipledMaterial::setThicknessMap, thicknessImage);
++ }
++
++ // attenuationDistance
++ {
++ ai_real attenuationDistance = 0.0f;
++ result = source.Get(AI_MATKEY_VOLUME_ATTENUATION_DISTANCE, attenuationDistance);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "attenuationDistance",
++ &QQuick3DPrincipledMaterial::setAttenuationDistance,
++ float(attenuationDistance));
++ }
++
++ // attenuationColor
++ {
++ aiColor3D attenuationColor;
++ result = source.Get(AI_MATKEY_VOLUME_ATTENUATION_COLOR, attenuationColor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "attenuationColor",
++ &QQuick3DPrincipledMaterial::setAttenuationColor,
++ aiColorToQColor(attenuationColor));
++ }
++ }
++
++
++ // KHR_materials_ior
++ {
++ ai_real ior = 0.0f;
++ result = source.Get(AI_MATKEY_REFRACTI, ior);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "indexOfRefraction",
++ &QQuick3DPrincipledMaterial::setIndexOfRefraction,
++ float(ior));
++ }
++
++ {
++ // opacity AI_MATKEY_OPACITY
++ ai_real opacity = 1.0f;
++ result = source.Get(AI_MATKEY_OPACITY, opacity);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "opacity", &QQuick3DPrincipledMaterial::setOpacity, float(opacity));
++
++ // opacityMap aiTextureType_OPACITY 0
++ if (auto opacityTexture = createTextureNode(source, aiTextureType_OPACITY, 0))
++ QSSGSceneDesc::setProperty(target, "opacityMap", &QQuick3DPrincipledMaterial::setOpacityMap, opacityTexture);
++ }
++
++ } else if (type == QSSGSceneDesc::Material::RuntimeType::DefaultMaterial) { // Ver1
++ int shadingModel = 0;
++ auto material = &source;
++ result = material->Get(AI_MATKEY_SHADING_MODEL, shadingModel);
++ // lighting
++ if (result == aiReturn_SUCCESS && (shadingModel == aiShadingMode_NoShading))
++ QSSGSceneDesc::setProperty(target, "lighting", &QQuick3DDefaultMaterial::setLighting, QQuick3DDefaultMaterial::Lighting::NoLighting);
++
++ if (auto diffuseMapTexture = createTextureNode(source, aiTextureType_DIFFUSE, 0)) {
++ QSSGSceneDesc::setProperty(target, "diffuseMap", &QQuick3DDefaultMaterial::setDiffuseMap, diffuseMapTexture);
++ } else {
++ // For some reason the normal behavior is that either you have a diffuseMap[s] or a diffuse color
++ // but no a mix of both... So only set the diffuse color if none of the diffuse maps are set:
++ aiColor3D diffuseColor;
++ result = material->Get(AI_MATKEY_COLOR_DIFFUSE, diffuseColor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "diffuseColor", &QQuick3DDefaultMaterial::setDiffuseColor, aiColorToQColor(diffuseColor));
++ }
++
++ if (auto emissiveTexture = createTextureNode(source, aiTextureType_EMISSIVE, 0))
++ QSSGSceneDesc::setProperty(target, "emissiveMap", &QQuick3DDefaultMaterial::setEmissiveMap, emissiveTexture);
++
++ // specularReflectionMap
++ if (auto specularTexture = createTextureNode(source, aiTextureType_SPECULAR, 0))
++ QSSGSceneDesc::setProperty(target, "specularMap", &QQuick3DDefaultMaterial::setSpecularMap, specularTexture);
++
++ // opacity AI_MATKEY_OPACITY
++ ai_real opacity;
++ result = material->Get(AI_MATKEY_OPACITY, opacity);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "opacity", &QQuick3DDefaultMaterial::setOpacity, float(opacity));
++
++ // opacityMap aiTextureType_OPACITY 0
++ if (auto opacityTexture = createTextureNode(source, aiTextureType_OPACITY, 0))
++ QSSGSceneDesc::setProperty(target, "opacityMap", &QQuick3DDefaultMaterial::setOpacityMap, opacityTexture);
++
++ // bumpMap aiTextureType_HEIGHT 0
++ if (auto bumpTexture = createTextureNode(source, aiTextureType_HEIGHT, 0)) {
++ QSSGSceneDesc::setProperty(target, "bumpMap", &QQuick3DDefaultMaterial::setBumpMap, bumpTexture);
++ // bumpAmount AI_MATKEY_BUMPSCALING
++ ai_real bumpAmount;
++ result = material->Get(AI_MATKEY_BUMPSCALING, bumpAmount);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "bumpAmount", &QQuick3DDefaultMaterial::setBumpAmount, float(bumpAmount));
++ }
++
++ // normalMap aiTextureType_NORMALS 0
++ if (auto normalTexture = createTextureNode(source, aiTextureType_NORMALS, 0))
++ QSSGSceneDesc::setProperty(target, "normalMap", &QQuick3DDefaultMaterial::setNormalMap, normalTexture);
++ } else if (type == QSSGSceneDesc::Material::RuntimeType::SpecularGlossyMaterial) {
++ {
++ aiColor4D albedoFactor;
++ result = source.Get(AI_MATKEY_COLOR_DIFFUSE, albedoFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "albedoColor", &QQuick3DSpecularGlossyMaterial::setAlbedoColor, aiColorToQColor(albedoFactor));
++ }
++
++ if (auto albedoTexture = createTextureNode(source, aiTextureType_DIFFUSE, 0)) {
++ QSSGSceneDesc::setProperty(target, "albedoMap", &QQuick3DSpecularGlossyMaterial::setAlbedoMap, albedoTexture);
++ QSSGSceneDesc::setProperty(target, "opacityChannel", &QQuick3DSpecularGlossyMaterial::setOpacityChannel, QQuick3DSpecularGlossyMaterial::TextureChannelMapping::A);
++ }
++
++ if (auto specularGlossinessTexture = createTextureNode(source, aiTextureType_SPECULAR, 0)) {
++ QSSGSceneDesc::setProperty(target, "specularMap", &QQuick3DSpecularGlossyMaterial::setSpecularMap, specularGlossinessTexture);
++ QSSGSceneDesc::setProperty(target, "glossinessMap", &QQuick3DSpecularGlossyMaterial::setGlossinessMap, specularGlossinessTexture);
++ QSSGSceneDesc::setProperty(target, "glossinessChannel", &QQuick3DSpecularGlossyMaterial::setGlossinessChannel, QQuick3DSpecularGlossyMaterial::TextureChannelMapping::A);
++ }
++
++ {
++ aiColor4D specularColorFactor;
++ result = source.Get(AI_MATKEY_COLOR_SPECULAR, specularColorFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "specularColor", &QQuick3DSpecularGlossyMaterial::setSpecularColor, aiColorToQColor(specularColorFactor));
++ }
++
++ {
++ ai_real glossinessFactor;
++ result = source.Get(AI_MATKEY_GLOSSINESS_FACTOR, glossinessFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "glossiness", &QQuick3DSpecularGlossyMaterial::setGlossiness, float(glossinessFactor));
++ }
++
++ if (auto normalTexture = createTextureNode(source, aiTextureType_NORMALS, 0)) {
++ QSSGSceneDesc::setProperty(target, "normalMap", &QQuick3DSpecularGlossyMaterial::setNormalMap, normalTexture);
++ {
++ ai_real normalScale;
++ result = source.Get(AI_MATKEY_GLTF_TEXTURE_SCALE(aiTextureType_NORMALS, 0), normalScale);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "normalStrength", &QQuick3DSpecularGlossyMaterial::setNormalStrength, float(normalScale));
++ }
++ }
++
++ // Occlusion Textures are not implimented (yet)
++ if (auto occlusionTexture = createTextureNode(source, aiTextureType_LIGHTMAP, 0)) {
++ QSSGSceneDesc::setProperty(target, "occlusionMap", &QQuick3DSpecularGlossyMaterial::setOcclusionMap, occlusionTexture);
++ QSSGSceneDesc::setProperty(target, "occlusionChannel", &QQuick3DSpecularGlossyMaterial::setOcclusionChannel, QQuick3DSpecularGlossyMaterial::TextureChannelMapping::R);
++ {
++ ai_real occlusionAmount;
++ result = source.Get(AI_MATKEY_GLTF_TEXTURE_STRENGTH(aiTextureType_LIGHTMAP, 0), occlusionAmount);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "occlusionAmount", &QQuick3DSpecularGlossyMaterial::setOcclusionAmount, float(occlusionAmount));
++ }
++ }
++
++ if (auto emissiveTexture = createTextureNode(source, aiTextureType_EMISSIVE, 0))
++ QSSGSceneDesc::setProperty(target, "emissiveMap", &QQuick3DSpecularGlossyMaterial::setEmissiveMap, emissiveTexture);
++
++ {
++ aiColor3D emissiveColorFactor;
++ result = source.Get(AI_MATKEY_COLOR_EMISSIVE, emissiveColorFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "emissiveFactor", &QQuick3DSpecularGlossyMaterial::setEmissiveFactor, QVector3D { emissiveColorFactor.r, emissiveColorFactor.g, emissiveColorFactor.b });
++ }
++
++ {
++ bool isDoubleSided;
++ result = source.Get(AI_MATKEY_TWOSIDED, isDoubleSided);
++ if (result == aiReturn_SUCCESS && isDoubleSided)
++ QSSGSceneDesc::setProperty(target, "cullMode", &QQuick3DSpecularGlossyMaterial::setCullMode, QQuick3DSpecularGlossyMaterial::CullMode::NoCulling);
++ }
++
++ {
++ aiString alphaMode;
++ result = source.Get(AI_MATKEY_GLTF_ALPHAMODE, alphaMode);
++ if (result == aiReturn_SUCCESS) {
++ auto mode = QQuick3DSpecularGlossyMaterial::AlphaMode::Default;
++ if (QByteArrayView(alphaMode.C_Str()) == "OPAQUE")
++ mode = QQuick3DSpecularGlossyMaterial::AlphaMode::Opaque;
++ else if (QByteArrayView(alphaMode.C_Str()) == "MASK")
++ mode = QQuick3DSpecularGlossyMaterial::AlphaMode::Mask;
++ else if (QByteArrayView(alphaMode.C_Str()) == "BLEND")
++ mode = QQuick3DSpecularGlossyMaterial::AlphaMode::Blend;
++
++ if (mode != QQuick3DSpecularGlossyMaterial::AlphaMode::Default) {
++ QSSGSceneDesc::setProperty(target, "alphaMode", &QQuick3DSpecularGlossyMaterial::setAlphaMode, mode);
++ // If the mode is mask, we also need to force OpaquePrePassDepthDraw mode
++ if (mode == QQuick3DSpecularGlossyMaterial::AlphaMode::Mask)
++ QSSGSceneDesc::setProperty(target, "depthDrawMode", &QQuick3DSpecularGlossyMaterial::setDepthDrawMode, QQuick3DMaterial::OpaquePrePassDepthDraw);
++ }
++ }
++ }
++
++ {
++ ai_real alphaCutoff;
++ result = source.Get(AI_MATKEY_GLTF_ALPHACUTOFF, alphaCutoff);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "alphaCutoff", &QQuick3DSpecularGlossyMaterial::setAlphaCutoff, float(alphaCutoff));
++ }
++
++ {
++ int shadingModel = 0;
++ result = source.Get(AI_MATKEY_SHADING_MODEL, shadingModel);
++ if (result == aiReturn_SUCCESS && shadingModel == aiShadingMode_Unlit)
++ QSSGSceneDesc::setProperty(target, "lighting", &QQuick3DSpecularGlossyMaterial::setLighting, QQuick3DSpecularGlossyMaterial::Lighting::NoLighting);
++ }
++
++
++ {
++ // Clearcoat Properties (KHR_materials_clearcoat)
++ // factor
++ {
++ ai_real clearcoatFactor = 0.0f;
++ result = source.Get(AI_MATKEY_CLEARCOAT_FACTOR, clearcoatFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "clearcoatAmount",
++ &QQuick3DSpecularGlossyMaterial::setClearcoatAmount,
++ float(clearcoatFactor));
++ }
++
++ // roughness
++ {
++ ai_real clearcoatRoughnessFactor = 0.0f;
++ result = source.Get(AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR, clearcoatRoughnessFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "clearcoatRoughnessAmount",
++ &QQuick3DSpecularGlossyMaterial::setClearcoatRoughnessAmount,
++ float(clearcoatRoughnessFactor));
++ }
++
++ // texture
++ if (auto clearcoatTexture = createTextureNode(source, AI_MATKEY_CLEARCOAT_TEXTURE))
++ QSSGSceneDesc::setProperty(target, "clearcoatMap", &QQuick3DSpecularGlossyMaterial::setClearcoatMap, clearcoatTexture);
++
++ // roughness texture
++ if (auto clearcoatRoughnessTexture = createTextureNode(source, AI_MATKEY_CLEARCOAT_ROUGHNESS_TEXTURE))
++ QSSGSceneDesc::setProperty(target,
++ "clearcoatRoughnessMap",
++ &QQuick3DSpecularGlossyMaterial::setClearcoatRoughnessMap,
++ clearcoatRoughnessTexture);
++
++ // normal texture
++ if (auto clearcoatNormalTexture = createTextureNode(source, AI_MATKEY_CLEARCOAT_NORMAL_TEXTURE)) {
++ QSSGSceneDesc::setProperty(target, "clearcoatNormalMap", &QQuick3DSpecularGlossyMaterial::setClearcoatNormalMap, clearcoatNormalTexture);
++
++ ai_real clearcoatNormalStrength = 0.0f;
++ result = source.Get(AI_MATKEY_GLTF_TEXTURE_SCALE(aiTextureType_CLEARCOAT, 2), clearcoatNormalTexture);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "clearcoatNormalStrength", &QQuick3DPrincipledMaterial::setClearcoatNormalStrength, float(clearcoatNormalStrength));
++ }
++ }
++
++ {
++ // Transmission Properties (KHR_materials_transmission)
++ // factor
++ {
++ ai_real transmissionFactor = 0.0f;
++ result = source.Get(AI_MATKEY_TRANSMISSION_FACTOR, transmissionFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "transmissionFactor",
++ &QQuick3DSpecularGlossyMaterial::setTransmissionFactor,
++ float(transmissionFactor));
++ }
++
++ // texture
++ {
++ if (auto transmissionImage = createTextureNode(source, AI_MATKEY_TRANSMISSION_TEXTURE))
++ QSSGSceneDesc::setProperty(target,
++ "transmissionMap",
++ &QQuick3DSpecularGlossyMaterial::setTransmissionMap,
++ transmissionImage);
++ }
++
++ }
++
++ {
++ // Volume Properties (KHR_materials_volume) [only used with transmission]
++ // thicknessFactor
++ {
++ ai_real thicknessFactor = 0.0f;
++ result = source.Get(AI_MATKEY_VOLUME_THICKNESS_FACTOR, thicknessFactor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target, "thicknessFactor", &QQuick3DSpecularGlossyMaterial::setThicknessFactor, float(thicknessFactor));
++ }
++
++ // thicknessMap
++ {
++ if (auto thicknessImage = createTextureNode(source, AI_MATKEY_VOLUME_THICKNESS_TEXTURE))
++ QSSGSceneDesc::setProperty(target, "thicknessMap", &QQuick3DSpecularGlossyMaterial::setThicknessMap, thicknessImage);
++ }
++
++ // attenuationDistance
++ {
++ ai_real attenuationDistance = 0.0f;
++ result = source.Get(AI_MATKEY_VOLUME_ATTENUATION_DISTANCE, attenuationDistance);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "attenuationDistance",
++ &QQuick3DSpecularGlossyMaterial::setAttenuationDistance,
++ float(attenuationDistance));
++ }
++
++ // attenuationColor
++ {
++ aiColor3D attenuationColor;
++ result = source.Get(AI_MATKEY_VOLUME_ATTENUATION_COLOR, attenuationColor);
++ if (result == aiReturn_SUCCESS)
++ QSSGSceneDesc::setProperty(target,
++ "attenuationColor",
++ &QQuick3DSpecularGlossyMaterial::setAttenuationColor,
++ aiColorToQColor(attenuationColor));
++ }
++ }
++ }
++ }
++
++ static void setCameraProperties(QSSGSceneDesc::Camera &target, const aiCamera &source, const aiNode &sourceNode, const SceneInfo &sceneInfo)
++ {
++ using namespace QSSGSceneDesc;
++
++ // assimp does not have a camera type but it works for gltf2 format.
++ target.runtimeType = (source.mHorizontalFOV == 0.0f) ? Node::RuntimeType::OrthographicCamera
++ : Node::RuntimeType::PerspectiveCamera;
++
++ // We assume these default forward and up vectors, so if this isn't
++ // the case we have to do additional transform
++ aiMatrix4x4 correctionMatrix;
++ bool needsCorrection = false;
++
++ // Workaround For FBX,
++ // assimp has a problem to set properties, mLookAt ans mUp
++ // and it takes too much time for correction.
++ // Quick3D will ignore these value and just use
++ // the initial differences between FBX and Quick3D.
++ if (sceneInfo.opt.fbxMode) {
++ aiMatrix4x4::RotationY(ai_real(M_PI / 2), correctionMatrix);
++ needsCorrection = true;
++ } else {
++ aiVector3D upQuick3D = aiVector3D(0, 1, 0);
++ if (source.mLookAt != aiVector3D(0, 0, -1)) {
++ aiMatrix4x4 lookAtCorrection;
++ aiMatrix4x4::FromToMatrix(aiVector3D(0, 0, -1), source.mLookAt, lookAtCorrection);
++ correctionMatrix *= lookAtCorrection;
++ needsCorrection = true;
++ upQuick3D *= lookAtCorrection;
++ }
++ if (source.mUp != upQuick3D) {
++ aiMatrix4x4 upCorrection;
++ aiMatrix4x4::FromToMatrix(upQuick3D, source.mUp, upCorrection);
++ correctionMatrix = upCorrection * correctionMatrix;
++ needsCorrection = true;
++ }
++ }
++
++ setNodeProperties(target, sourceNode, sceneInfo, needsCorrection ? &correctionMatrix : nullptr);
++
++ // clipNear and clipFar
++ if (target.runtimeType == Node::RuntimeType::PerspectiveCamera) {
++ setProperty(target, "clipNear", &QQuick3DPerspectiveCamera::setClipNear, source.mClipPlaneNear);
++ setProperty(target, "clipFar", &QQuick3DPerspectiveCamera::setClipFar, source.mClipPlaneFar);
++ } else { //OrthographicCamera
++ setProperty(target, "clipNear", &QQuick3DOrthographicCamera::setClipNear, source.mClipPlaneNear);
++ setProperty(target, "clipFar", &QQuick3DOrthographicCamera::setClipFar, source.mClipPlaneFar);
++ }
++
++ if (target.runtimeType == Node::RuntimeType::PerspectiveCamera) {
++ // fieldOfView
++ // mHorizontalFOV is defined as a half horizontal fov
++ // in the assimp header but it seems not half now.
++ const float fov = qRadiansToDegrees(source.mHorizontalFOV);
++ setProperty(target, "fieldOfView", &QQuick3DPerspectiveCamera::setFieldOfView, fov);
++
++ // isFieldOfViewHorizontal
++ setProperty(target, "fieldOfViewOrientation", &QQuick3DPerspectiveCamera::setFieldOfViewOrientation,
++ QQuick3DPerspectiveCamera::FieldOfViewOrientation::Horizontal);
++ } else { //OrthographicCamera
++ const float width = source.mOrthographicWidth * 2.0f;
++ const float height = width / source.mAspect;
++ setProperty(target, "horizontalMagnification", &QQuick3DOrthographicCamera::setHorizontalMagnification, width);
++ setProperty(target, "verticalMagnification", &QQuick3DOrthographicCamera::setVerticalMagnification, height);
++ }
++ // projectionMode
++
++ // scaleMode
++
++ // scaleAnchor
++
++ // frustomScaleX
++
++ // frustomScaleY
++ }
++
++ static void setLightProperties(QSSGSceneDesc::Light &target, const aiLight &source, const aiNode &sourceNode, const SceneInfo &sceneInfo)
++ {
++ // We assume that the direction vector for a light is (0, 0, -1)
++ // so if the direction vector is non-null, but not (0, 0, -1) we
++ // need to correct the translation
++ aiMatrix4x4 correctionMatrix;
++ bool needsCorrection = false;
++ if (source.mDirection != aiVector3D(0, 0, 0)) {
++ if (source.mDirection != aiVector3D(0, 0, -1)) {
++ aiMatrix4x4::FromToMatrix(aiVector3D(0, 0, -1), source.mDirection, correctionMatrix);
++ needsCorrection = true;
++ }
++ }
++
++ // lightType
++ static const auto asQtLightType = [](aiLightSourceType type) {
++ switch (type) {
++ case aiLightSource_AMBIENT:
++ Q_FALLTHROUGH();
++ case aiLightSource_DIRECTIONAL:
++ return QSSGSceneDesc::Light::RuntimeType::DirectionalLight;
++ case aiLightSource_POINT:
++ return QSSGSceneDesc::Light::RuntimeType::PointLight;
++ case aiLightSource_SPOT:
++ return QSSGSceneDesc::Light::RuntimeType::SpotLight;
++ default:
++ return QSSGSceneDesc::Light::RuntimeType::PointLight;
++ }
++ };
++
++ target.runtimeType = asQtLightType(source.mType);
++
++ setNodeProperties(target, sourceNode, sceneInfo, needsCorrection ? &correctionMatrix : nullptr);
++
++ // brightness
++ // Assimp has no property related to brightness or intensity.
++ // They are multiplied to diffuse, ambient and specular colors.
++ // For extracting the property value, we will check the maximum value of them.
++ // (In most cases, Assimp uses the same specular values with diffuse values,
++ // so we will compare just components of the diffuse and the ambient)
++ float brightness = qMax(qMax(1.0f, source.mColorDiffuse.r),
++ qMax(source.mColorDiffuse.g, source.mColorDiffuse.b));
++
++ // ambientColor
++ if (source.mType == aiLightSource_AMBIENT) {
++ brightness = qMax(qMax(brightness, source.mColorAmbient.r),
++ qMax(source.mColorAmbient.g, source.mColorAmbient.b));
++
++ // We only want ambient light color if it is explicit
++ const QColor ambientColor = QColor::fromRgbF(source.mColorAmbient.r / brightness,
++ source.mColorAmbient.g / brightness,
++ source.mColorAmbient.b / brightness);
++ QSSGSceneDesc::setProperty(target, "ambientColor", &QQuick3DAbstractLight::setAmbientColor, ambientColor);
++ }
++
++ // diffuseColor
++ const QColor diffuseColor = QColor::fromRgbF(source.mColorDiffuse.r / brightness,
++ source.mColorDiffuse.g / brightness,
++ source.mColorDiffuse.b / brightness);
++ QSSGSceneDesc::setProperty(target, "color", &QQuick3DAbstractLight::setColor, diffuseColor);
++
++ // describe brightness here
++ QSSGSceneDesc::setProperty(target, "brightness", &QQuick3DAbstractLight::setBrightness, brightness);
++
++ const bool isSpot = (source.mType == aiLightSource_SPOT);
++ if (source.mType == aiLightSource_POINT || isSpot) {
++ // constantFade
++ // Some assets have this constant attenuation value as 0.0f and it makes light attenuation makes infinite at distance 0.
++ // In that case, we will use the default constant attenuation, 1.0f.
++ const bool hasAttConstant = !qFuzzyIsNull(source.mAttenuationConstant);
++
++ if (isSpot) {
++ if (hasAttConstant)
++ QSSGSceneDesc::setProperty(target, "constantFade", &QQuick3DSpotLight::setConstantFade, source.mAttenuationConstant);
++ QSSGSceneDesc::setProperty(target, "linearFade", &QQuick3DSpotLight::setLinearFade, source.mAttenuationLinear * 100.0f);
++ QSSGSceneDesc::setProperty(target, "quadraticFade", &QQuick3DSpotLight::setQuadraticFade, source.mAttenuationQuadratic * 10000.0f);
++ QSSGSceneDesc::setProperty(target, "coneAngle", &QQuick3DSpotLight::setConeAngle, qRadiansToDegrees(source.mAngleOuterCone) * 2.0f);
++ QSSGSceneDesc::setProperty(target, "innerConeAngle", &QQuick3DSpotLight::setInnerConeAngle, qRadiansToDegrees(source.mAngleInnerCone) * 2.0f);
++ } else {
++ if (hasAttConstant)
++ QSSGSceneDesc::setProperty(target, "constantFade", &QQuick3DPointLight::setConstantFade, source.mAttenuationConstant);
++ QSSGSceneDesc::setProperty(target, "linearFade", &QQuick3DPointLight::setLinearFade, source.mAttenuationLinear * 100.0f);
++ QSSGSceneDesc::setProperty(target, "quadraticFade", &QQuick3DPointLight::setQuadraticFade, source.mAttenuationQuadratic * 10000.0f);
++ }
++ }
++ // castShadow
++
++ // shadowBias
++
++ // shadowFactor
++
++ // shadowMapResolution
++
++ // shadowMapFar
++
++ // shadowMapFieldOfView
++
++ // shadowFilter
++ }
++
++ using MorphAttributes = QQuick3DMorphTarget::MorphTargetAttributes;
++ struct MorphProperty {
++ QByteArray name;
++ MorphAttributes attrib;
++ float weight;
++ };
++
++ static void setModelProperties(QSSGSceneDesc::Model &target, const aiNode &source, const SceneInfo &sceneInfo)
++ {
++ if (source.mNumMeshes == 0)
++ return;
++
++ auto &targetScene = target.scene;
++ const auto &srcScene = sceneInfo.scene;
++ // TODO: Correction and scale
++ setNodeProperties(target, source, sceneInfo, nullptr);
++
++ auto &meshStorage = targetScene->meshStorage;
++ auto &materialMap = sceneInfo.materialMap;
++ auto &meshMap = sceneInfo.meshMap;
++ auto &skinMap = sceneInfo.skinMap;
++ auto &mesh2skin = sceneInfo.mesh2skin;
++
++ QVarLengthArray<QSSGSceneDesc::Material *> materials;
++ materials.reserve(source.mNumMeshes); // Assumig there's max one material per mesh.
++
++ QString errorString;
++
++ const auto ensureMaterial = [&](qsizetype materialIndex) {
++ // Get the material for the mesh
++ auto &material = materialMap[materialIndex];
++ // Check if we need to create a new scene node for this material
++ auto targetMat = material.second;
++ if (targetMat == nullptr) {
++ const aiMaterial *sourceMat = material.first;
++
++ auto currentMaterialType = QSSGSceneDesc::Material::RuntimeType::PrincipledMaterial;
++ ai_real glossinessFactor;
++ aiReturn result = sourceMat->Get(AI_MATKEY_GLOSSINESS_FACTOR, glossinessFactor);
++ if (result == aiReturn_SUCCESS)
++ currentMaterialType = QSSGSceneDesc::Material::RuntimeType::SpecularGlossyMaterial;
++
++ targetMat = new QSSGSceneDesc::Material(currentMaterialType);
++ QSSGSceneDesc::addNode(target, *targetMat);
++ setMaterialProperties(*targetMat, *sourceMat, sceneInfo, currentMaterialType);
++ material.second = targetMat;
++ }
++
++ Q_ASSERT(targetMat != nullptr && material.second != nullptr);
++ // If these don't match then somethings broken...
++ Q_ASSERT(srcScene.mMaterials[materialIndex] == material.first);
++ materials.push_back(targetMat);
++ };
++
++ AssimpUtils::MeshList meshes;
++ qint16 skinIdx = -1;
++ // Combine all the meshes referenced by this model into a single MultiMesh file
++ // For the morphing, the target mesh must have the same AnimMeshes.
++ // It means if only one mesh has a morphing animation, the other sub-meshes will
++ // get null target attributes. However this case might not be common.
++ // These submeshes will animate with the same morphing weight!
++
++ // If meshes have separate skins, they should not be combined. GLTF2 does not
++ // seem to have problems related with this case, but When we use runtime asset
++ // for other formats, this case must be checked again.
++ // Here, we will use only the first skin in the mesh list
++ const auto combineMeshes = [&](const aiNode &source, aiMesh **sceneMeshes) {
++ for (qsizetype i = 0, end = source.mNumMeshes; i != end; ++i) {
++ const aiMesh &mesh = *sceneMeshes[source.mMeshes[i]];
++ ensureMaterial(mesh.mMaterialIndex);
++ if (skinIdx == -1 && mesh.HasBones())
++ skinIdx = mesh2skin[source.mMeshes[i]];
++ meshes.push_back(&mesh);
++ }
++ };
++
++ const auto createMeshNode = [&](const aiString &name) {
++ auto meshData = AssimpUtils::generateMeshData(srcScene,
++ meshes,
++ sceneInfo.opt.useFloatJointIndices,
++ sceneInfo.opt.generateMeshLODs,
++ sceneInfo.opt.lodNormalMergeAngle,
++ sceneInfo.opt.lodNormalSplitAngle,
++ errorString);
++ meshStorage.push_back(std::move(meshData));
++
++ const auto idx = meshStorage.size() - 1;
++ // For multimeshes we'll use the model name, but for single meshes we'll use the mesh name.
++ return new QSSGSceneDesc::Mesh(fromAiString(name), idx);
++ };
++
++ QSSGSceneDesc::Mesh *meshNode = nullptr;
++
++ const bool isMultiMesh = (source.mNumMeshes > 1);
++ if (isMultiMesh) {
++ // result is stored in 'meshes'
++ combineMeshes(source, srcScene.mMeshes);
++ Q_ASSERT(!meshes.isEmpty());
++ meshNode = createMeshNode(source.mName);
++ QSSGSceneDesc::addNode(target, *meshNode);
++ } else { // single mesh (We shouldn't be here if there are no meshes...)
++ Q_ASSERT(source.mNumMeshes == 1);
++ auto &mesh = meshMap[*source.mMeshes];
++ meshNode = mesh.second;
++ if (meshNode == nullptr) {
++ meshes = {mesh.first};
++ if (mesh.first->HasBones())
++ skinIdx = mesh2skin[*source.mMeshes];
++ mesh.second = meshNode = createMeshNode(mesh.first->mName);
++ QSSGSceneDesc::addNode(target, *meshNode); // We only add this the first time we create it.
++ }
++ ensureMaterial(mesh.first->mMaterialIndex);
++ Q_ASSERT(meshNode != nullptr && mesh.second != nullptr);
++ }
++
++ if (meshNode)
++ QSSGSceneDesc::setProperty(target, "source", &QQuick3DModel::setSource, QVariant::fromValue(meshNode));
++
++ if (skinIdx != -1) {
++ auto &skin = skinMap[skinIdx];
++ skin.node = new QSSGSceneDesc::Skin;
++ QSSGSceneDesc::setProperty(target, "skin", &QQuick3DModel::setSkin, skin.node);
++ QSSGSceneDesc::addNode(target, *skin.node);
++ // Skins' properties wil be set after all the nodes are processed
++ }
++
++ // materials
++ // Note that we use a QVector/QList here instead of a QQmlListProperty, as that would be really inconvenient.
++ // Since we don't create any runtime objects at this point, the list also contains the node type that corresponds with the
++ // type expected to be in the list (this is ensured at compile-time).
++ QSSGSceneDesc::setProperty(target, "materials", &QQuick3DModel::materials, materials);
++ }
++
++ static QSSGSceneDesc::Node *createSceneNode(const NodeInfo &nodeInfo,
++ const aiNode &srcNode,
++ QSSGSceneDesc::Node &parent,
++ const SceneInfo &sceneInfo)
++ {
++ QSSGSceneDesc::Node *node = nullptr;
++ const auto &srcScene = sceneInfo.scene;
++ switch (nodeInfo.type) {
++ case QSSGSceneDesc::Node::Type::Camera:
++ {
++ const auto &srcType = *srcScene.mCameras[nodeInfo.index];
++ // We set the initial rt-type to 'Custom', but we'll change it when updateing the properties.
++ auto targetType = new QSSGSceneDesc::Camera(QSSGSceneDesc::Node::RuntimeType::CustomCamera);
++ QSSGSceneDesc::addNode(parent, *targetType);
++ setCameraProperties(*targetType, srcType, srcNode, sceneInfo);
++ node = targetType;
++ }
++ break;
++ case QSSGSceneDesc::Node::Type::Light:
++ {
++ const auto &srcType = *srcScene.mLights[nodeInfo.index];
++ // Initial type is DirectonalLight, but will be change (if needed) when setting the properties.
++ auto targetType = new QSSGSceneDesc::Light(QSSGSceneDesc::Node::RuntimeType::DirectionalLight);
++ QSSGSceneDesc::addNode(parent, *targetType);
++ setLightProperties(*targetType, srcType, srcNode, sceneInfo);
++ node = targetType;
++ }
++ break;
++ case QSSGSceneDesc::Node::Type::Model:
++ {
++ auto target = new QSSGSceneDesc::Model;
++ QSSGSceneDesc::addNode(parent, *target);
++ setModelProperties(*target, srcNode, sceneInfo);
++ node = target;
++ }
++ break;
++ case QSSGSceneDesc::Node::Type::Joint:
++ {
++ auto target = new QSSGSceneDesc::Joint;
++ QSSGSceneDesc::addNode(parent, *target);
++ setNodeProperties(*target, srcNode, sceneInfo, nullptr);
++ QSSGSceneDesc::setProperty(*target, "index", &QQuick3DJoint::setIndex, qint32(nodeInfo.index));
++ node = target;
++ }
++ break;
++ case QSSGSceneDesc::Node::Type::Transform:
++ {
++ node = new QSSGSceneDesc::Node(QSSGSceneDesc::Node::Type::Transform, QSSGSceneDesc::Node::RuntimeType::Node);
++ QSSGSceneDesc::addNode(parent, *node);
++ // TODO: arguments for correction
++ setNodeProperties(*node, srcNode, sceneInfo, nullptr);
++ }
++ break;
++ default:
++ break;
++ }
++
++ return node;
++ }
++
++ static void processNode(const SceneInfo &sceneInfo, const aiNode &source, QSSGSceneDesc::Node &parent, const NodeMap &nodeMap, AnimationNodeMap &animationNodes)
++ {
++ QSSGSceneDesc::Node *node = nullptr;
++ if (source.mNumMeshes != 0) {
++ // Process morphTargets first and then add them to the modelNode
++ using It = decltype(source.mNumMeshes);
++ QVarLengthArray<MorphProperty> morphProps;
++ for (It i = 0, end = source.mNumMeshes; i != end; ++i) {
++ const auto &srcScene = sceneInfo.scene;
++ const aiMesh &mesh = *srcScene.mMeshes[source.mMeshes[i]];
++ const quint32 numMorphTargets = mesh.mNumAnimMeshes;
++ if (numMorphTargets && mesh.mAnimMeshes) {
++ morphProps.reserve(numMorphTargets);
++ for (uint j = 0; j < numMorphTargets; ++j) {
++ const auto &animMesh = mesh.mAnimMeshes[j];
++ MorphAttributes attrib;
++ if (animMesh->HasPositions())
++ attrib |= QQuick3DMorphTarget::MorphTargetAttribute::Position;
++ if (animMesh->HasNormals())
++ attrib |= QQuick3DMorphTarget::MorphTargetAttribute::Normal;
++ if (animMesh->HasTangentsAndBitangents()) {
++ attrib |= QQuick3DMorphTarget::MorphTargetAttribute::Tangent;
++ attrib |= QQuick3DMorphTarget::MorphTargetAttribute::Binormal;
++ }
++ morphProps.append({ fromAiString(animMesh->mName),
++ attrib,
++ animMesh->mWeight });
++ }
++ }
++ }
++ node = createSceneNode(NodeInfo { 0, QSSGSceneDesc::Node::Type::Model }, source, parent, sceneInfo);
++ if (!morphProps.isEmpty()) {
++ const QString nodeName(source.mName.C_Str());
++ QVarLengthArray<QSSGSceneDesc::MorphTarget *> morphTargets;
++ morphTargets.reserve(morphProps.size());
++ for (int i = 0, end = morphProps.size(); i != end; ++i) {
++ const auto morphProp = morphProps.at(i);
++
++ auto morphNode = new QSSGSceneDesc::MorphTarget;
++ QSSGSceneDesc::addNode(*node, *morphNode);
++ QSSGSceneDesc::setProperty(*morphNode, "weight", &QQuick3DMorphTarget::setWeight, morphProp.weight);
++ QSSGSceneDesc::setProperty(*morphNode, "attributes", &QQuick3DMorphTarget::setAttributes, morphProp.attrib);
++ morphNode->name = morphProp.name;
++ morphTargets.push_back(morphNode);
++
++ if (!animationNodes.isEmpty()) {
++ QString morphTargetName = nodeName + QStringLiteral("_morph") + QString::number(i);
++ const auto aNodeIt = animationNodes.find(morphTargetName.toUtf8());
++ if (aNodeIt != animationNodes.end() && aNodeIt.value() == nullptr)
++ *aNodeIt = morphNode;
++ }
++ }
++ QSSGSceneDesc::setProperty(*node, "morphTargets", &QQuick3DModel::morphTargets, morphTargets);
++ }
++ }
++
++ if (!node) {
++ NodeInfo nodeInfo{ 0, QSSGSceneDesc::Node::Type::Transform };
++ if (auto it = nodeMap.constFind(&source); it != nodeMap.constEnd())
++ nodeInfo = (*it);
++ node = createSceneNode(nodeInfo, source, parent, sceneInfo);
++ }
++
++ if (!node)
++ node = &parent;
++
++ Q_ASSERT(node->scene);
++
++ // Check if this node is a target for an animation
++ if (!animationNodes.isEmpty()) {
++ const auto &nodeName = source.mName;
++ auto aNodeIt = animationNodes.find(QByteArray{nodeName.C_Str(), qsizetype(nodeName.length)});
++ if (aNodeIt != animationNodes.end() && aNodeIt.value() == nullptr)
++ *aNodeIt = node;
++ }
++
++ // Process child nodes
++ using It = decltype (source.mNumChildren);
++ for (It i = 0, end = source.mNumChildren; i != end; ++i)
++ processNode(sceneInfo, **(source.mChildren + i), *node, nodeMap, animationNodes);
++ }
++
++ static QSSGSceneDesc::Animation::KeyPosition toAnimationKey(const aiVectorKey &key, qreal freq) {
++ const auto flag = quint16(QSSGSceneDesc::Animation::KeyPosition::KeyType::Time) | quint16(QSSGSceneDesc::Animation::KeyPosition::ValueType::Vec3);
++ return QSSGSceneDesc::Animation::KeyPosition { QVector4D{ key.mValue.x, key.mValue.y, key.mValue.z, 0.0f }, float(key.mTime * freq), flag };
++ }
++
++ static QSSGSceneDesc::Animation::KeyPosition toAnimationKey(const aiQuatKey &key, qreal freq) {
++ const auto flag = quint16(QSSGSceneDesc::Animation::KeyPosition::KeyType::Time) | quint16(QSSGSceneDesc::Animation::KeyPosition::ValueType::Quaternion);
++ return QSSGSceneDesc::Animation::KeyPosition { QVector4D{ key.mValue.x, key.mValue.y, key.mValue.z, key.mValue.w }, float(key.mTime * freq), flag };
++ }
++
++ static QSSGSceneDesc::Animation::KeyPosition toAnimationKey(const aiMeshMorphKey &key, qreal freq, uint morphId) {
++ const auto flag = quint16(QSSGSceneDesc::Animation::KeyPosition::KeyType::Time) | quint16(QSSGSceneDesc::Animation::KeyPosition::ValueType::Number);
++ return QSSGSceneDesc::Animation::KeyPosition { QVector4D{ float(key.mWeights[morphId]), 0.0f, 0.0f, 0.0f }, float(key.mTime * freq), flag };
++ }
++
++ static bool checkBooleanOption(const QString &optionName, const QJsonObject &options)
++ {
++ const auto it = options.constFind(optionName);
++ const auto end = options.constEnd();
++ QJsonValue value;
++ if (it != end) {
++ if (it->isObject())
++ value = it->toObject().value("value");
++ else
++ value = it.value();
++ }
++ return value.toBool();
++ }
++
++ static qreal getRealOption(const QString &optionName, const QJsonObject &options)
++ {
++ const auto it = options.constFind(optionName);
++ const auto end = options.constEnd();
++ QJsonValue value;
++ if (it != end) {
++ if (it->isObject())
++ value = it->toObject().value("value");
++ else
++ value = it.value();
++ }
++
++ return value.toDouble();
++ }
++
++ #define demonPostProcessPresets ( \
++ aiProcess_CalcTangentSpace | \
++ aiProcess_JoinIdenticalVertices | \
++ aiProcess_ImproveCacheLocality | \
++ aiProcess_RemoveRedundantMaterials | \
++ aiProcess_SplitLargeMeshes | \
++ aiProcess_Triangulate | \
++ aiProcess_GenUVCoords | \
++ aiProcess_SortByPType | \
++ aiProcess_FindDegenerates | \
++ aiProcess_FindInvalidData | \
++ 0 )
++
++ static aiPostProcessSteps processOptions(const QJsonObject &optionsObject, std::unique_ptr<Assimp::Importer> &importer) {
++ aiPostProcessSteps postProcessSteps = aiPostProcessSteps(aiProcess_Triangulate | aiProcess_SortByPType);;
++
++ // Setup import settings based given options
++ // You can either pass the whole options object, or just the "options" object
++ // so get the right scope.
++ QJsonObject options = optionsObject;
++
++ if (auto it = options.constFind("options"), end = options.constEnd(); it != end)
++ options = it->toObject();
++
++ if (options.isEmpty())
++ return postProcessSteps;
++
++ // parse the options list for values
++
++ if (checkBooleanOption(QStringLiteral("calculateTangentSpace"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_CalcTangentSpace);
++
++ if (checkBooleanOption(QStringLiteral("joinIdenticalVertices"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_JoinIdenticalVertices);
++
++ if (checkBooleanOption(QStringLiteral("generateNormals"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_GenNormals);
++
++ if (checkBooleanOption(QStringLiteral("generateSmoothNormals"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_GenSmoothNormals);
++
++ if (checkBooleanOption(QStringLiteral("splitLargeMeshes"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_SplitLargeMeshes);
++
++ if (checkBooleanOption(QStringLiteral("preTransformVertices"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_PreTransformVertices);
++
++ if (checkBooleanOption(QStringLiteral("improveCacheLocality"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_ImproveCacheLocality);
++
++ if (checkBooleanOption(QStringLiteral("removeRedundantMaterials"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_RemoveRedundantMaterials);
++
++ if (checkBooleanOption(QStringLiteral("fixInfacingNormals"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_FixInfacingNormals);
++
++ if (checkBooleanOption(QStringLiteral("findDegenerates"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_FindDegenerates);
++
++ if (checkBooleanOption(QStringLiteral("findInvalidData"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_FindInvalidData);
++
++ if (checkBooleanOption(QStringLiteral("transformUVCoordinates"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_TransformUVCoords);
++
++ if (checkBooleanOption(QStringLiteral("findInstances"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_FindInstances);
++
++ if (checkBooleanOption(QStringLiteral("optimizeMeshes"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_OptimizeMeshes);
++
++ if (checkBooleanOption(QStringLiteral("optimizeGraph"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_OptimizeGraph);
++
++ if (checkBooleanOption(QStringLiteral("dropNormals"), options))
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_DropNormals);
++
++ aiComponent removeComponents = aiComponent(0);
++
++ if (checkBooleanOption(QStringLiteral("removeComponentNormals"), options))
++ removeComponents = aiComponent(removeComponents | aiComponent_NORMALS);
++
++ if (checkBooleanOption(QStringLiteral("removeComponentTangentsAndBitangents"), options))
++ removeComponents = aiComponent(removeComponents | aiComponent_TANGENTS_AND_BITANGENTS);
++
++ if (checkBooleanOption(QStringLiteral("removeComponentColors"), options))
++ removeComponents = aiComponent(removeComponents | aiComponent_COLORS);
++
++ if (checkBooleanOption(QStringLiteral("removeComponentUVs"), options))
++ removeComponents = aiComponent(removeComponents | aiComponent_TEXCOORDS);
++
++ if (checkBooleanOption(QStringLiteral("removeComponentBoneWeights"), options))
++ removeComponents = aiComponent(removeComponents | aiComponent_BONEWEIGHTS);
++
++ if (checkBooleanOption(QStringLiteral("removeComponentAnimations"), options))
++ removeComponents = aiComponent(removeComponents | aiComponent_ANIMATIONS);
++
++ if (checkBooleanOption(QStringLiteral("removeComponentTextures"), options))
++ removeComponents = aiComponent(removeComponents | aiComponent_TEXTURES);
++
++ if (removeComponents != aiComponent(0)) {
++ postProcessSteps = aiPostProcessSteps(postProcessSteps | aiProcess_RemoveComponent);
++ importer->SetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS, removeComponents);
++ }
++
++ bool preservePivots = checkBooleanOption(QStringLiteral("fbxPreservePivots"), options);
++ importer->SetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, preservePivots);
++
++ return postProcessSteps;
++ }
++
++ static SceneInfo::Options processSceneOptions(const QJsonObject &optionsObject) {
++ SceneInfo::Options sceneOptions;
++
++ // Setup import settings based given options
++ // You can either pass the whole options object, or just the "options" object
++ // so get the right scope.
++ QJsonObject options = optionsObject;
++
++ if (auto it = options.constFind("options"), end = options.constEnd(); it != end)
++ options = it->toObject();
++
++ if (options.isEmpty())
++ return sceneOptions;
++
++ if (checkBooleanOption(QStringLiteral("globalScale"), options)) {
++ sceneOptions.globalScaleValue = getRealOption(QStringLiteral("globalScaleValue"), options);
++ if (sceneOptions.globalScaleValue == 0.0)
++ sceneOptions.globalScaleValue = 1.0;
++ }
++
++ sceneOptions.designStudioWorkarounds = checkBooleanOption(QStringLiteral("designStudioWorkarounds"), options);
++ sceneOptions.useFloatJointIndices = checkBooleanOption(QStringLiteral("useFloatJointIndices"), options);
++ sceneOptions.forceMipMapGeneration = checkBooleanOption(QStringLiteral("generateMipMaps"), options);
++ sceneOptions.binaryKeyframes = checkBooleanOption(QStringLiteral("useBinaryKeyframes"), options);
++ sceneOptions.generateMeshLODs = checkBooleanOption(QStringLiteral("generateMeshLevelsOfDetail"), options);
++ if (sceneOptions.generateMeshLODs) {
++ bool recalculateLODNormals = checkBooleanOption(QStringLiteral("recalculateLodNormals"), options);
++ if (recalculateLODNormals) {
++ qreal mergeAngle = getRealOption(QStringLiteral("recalculateLodNormalsMergeAngle"), options);
++ sceneOptions.lodNormalMergeAngle = qBound(0.0, mergeAngle, 270.0);
++ qreal splitAngle = getRealOption(QStringLiteral("recalculateLodNormalsSplitAngle"), options);
++ sceneOptions.lodNormalSplitAngle = qBound(0.0, splitAngle, 270.0);
++ } else {
++ sceneOptions.lodNormalMergeAngle = 0.0;
++ sceneOptions.lodNormalSplitAngle = 0.0;
++ }
++ }
++ return sceneOptions;
++ }
++
++ static QString importImp(const QUrl &url, const QJsonObject &options, QSSGSceneDesc::Scene &targetScene)
++ {
++ auto filePath = url.path();
++
++ const bool maybeLocalFile = QQmlFile::isLocalFile(url);
++ if (maybeLocalFile && !QFileInfo::exists(filePath))
++ filePath = QQmlFile::urlToLocalFileOrQrc(url);
++
++ auto sourceFile = QFileInfo(filePath);
++ if (!sourceFile.exists())
++ return QLatin1String("File not found");
++ targetScene.sourceDir = sourceFile.path();
++
++ std::unique_ptr<Assimp::Importer> importer(new Assimp::Importer());
++
++ // Setup import from Options
++ aiPostProcessSteps postProcessSteps;
++ if (options.isEmpty())
++ postProcessSteps = aiPostProcessSteps(demonPostProcessPresets);
++ else
++ postProcessSteps = processOptions(options, importer);
++
++ // Remove primitives that are not Triangles
++ importer->SetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, aiPrimitiveType_POINT | aiPrimitiveType_LINE);
++ importer->SetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_USE_COLLADA_NAMES, 1);
++
++ if (filePath.startsWith(":"))
++ importer->SetIOHandler(new ResourceIOSystem);
++ #ifdef Q_OS_WASM
++ // Always use QFile-based IO on wasm, so that URL schemes like
++ // weblocalfile: are handled by Qt's file engine abstraction.
++ else
++ importer->SetIOHandler(new ResourceIOSystem);
++ #endif
++
++ auto sourceScene = importer->ReadFile(filePath.toStdString(), postProcessSteps);
++ if (!sourceScene) {
++ // Scene failed to load, use logger to get the reason
++ return QString::fromLocal8Bit(importer->GetErrorString());
++ }
++
++ // For simplicity, and convenience, we'll just use the file path as the id.
++ // DO NOT USE it for anything else, once the scene is created there's no
++ // real connection to the source asset file.
++ targetScene.id = sourceFile.canonicalFilePath();
++
++ // Assuming consistent type usage
++ using It = decltype(sourceScene->mNumMeshes);
++
++ // Before we can start processing the scene we start my mapping out the nodes
++ // we can tell the type of.
++ const auto &srcRootNode = *sourceScene->mRootNode;
++ NodeMap nodeMap;
++ // We need to know which nodes are animated so we can map _our_ animation data to
++ // the target node (in Assimp this is string based mapping).
++ AnimationNodeMap animatingNodes;
++ {
++ if (sourceScene->HasLights()) {
++ for (It i = 0, end = sourceScene->mNumLights; i != end; ++i) {
++ const auto &type = *sourceScene->mLights[i];
++ if (auto node = srcRootNode.FindNode(type.mName))
++ nodeMap[node] = { i, NodeInfo::Type::Light };
++ }
++ }
++
++ if (sourceScene->HasCameras()) {
++ for (It i = 0, end = sourceScene->mNumCameras; i != end; ++i) {
++ const auto &srcCam = *sourceScene->mCameras[i];
++ if (auto node = srcRootNode.FindNode(srcCam.mName))
++ nodeMap[node] = { i, NodeInfo::Type::Camera };
++ }
++ }
++
++ if (sourceScene->HasAnimations()) {
++ for (It i = 0, end = sourceScene->mNumAnimations; i != end; ++i) {
++ const auto &srcAnim = *sourceScene->mAnimations[i];
++ const auto channelCount = srcAnim.mNumChannels;
++ for (It cIdx = 0; cIdx != channelCount; ++cIdx) {
++ const auto &srcChannel = srcAnim.mChannels[cIdx];
++ const auto &nodeName = srcChannel->mNodeName;
++ if (nodeName.length > 0) {
++ // We'll update this once we've created the node!
++ QByteArray name(nodeName.C_Str(), qsizetype(nodeName.length));
++ if (!animatingNodes.contains(name))
++ animatingNodes.insert(name, nullptr);
++ }
++ }
++ const auto morphChannelCount = srcAnim.mNumMorphMeshChannels;
++ for (It cIdx = 0; cIdx != morphChannelCount; ++cIdx) {
++ const auto &srcChannel = srcAnim.mMorphMeshChannels[cIdx];
++ const auto &nodeName = srcChannel->mName;
++ if (nodeName.length > 0) {
++ const auto morphKeys = srcChannel->mKeys;
++ const auto numMorphTargets = morphKeys[0].mNumValuesAndWeights;
++ // MorphTarget's animations are stored with a name,
++ // "<nodeName> + '_morph' + <targetNumber>"
++ for (It j = 0; j < numMorphTargets; ++j) {
++ QString morphTargetName(nodeName.C_Str());
++ morphTargetName += QStringLiteral("_morph") + QString::number(j);
++ animatingNodes.insert(morphTargetName.toUtf8(), nullptr);
++ }
++ }
++ }
++ }
++ }
++ }
++
++ // We'll use these to ensure we don't re-create resources.
++ const auto materialCount = sourceScene->mNumMaterials;
++ SceneInfo::MaterialMap materials;
++ materials.reserve(materialCount);
++
++ const auto meshCount = sourceScene->mNumMeshes;
++ SceneInfo::MeshMap meshes;
++ meshes.reserve(meshCount);
++ SceneInfo::Mesh2SkinMap mesh2skin;
++ mesh2skin.reserve(meshCount);
++
++ const auto embeddedTextureCount = sourceScene->mNumTextures;
++ SceneInfo::EmbeddedTextureMap embeddedTextures;
++
++ SceneInfo::SkinMap skins;
++
++ for (It i = 0; i != materialCount; ++i)
++ materials.push_back({sourceScene->mMaterials[i], nullptr});
++
++ for (It i = 0; i != meshCount; ++i) {
++ meshes.push_back({sourceScene->mMeshes[i], nullptr});
++ if (sourceScene->mMeshes[i]->HasBones()) {
++ mesh2skin.push_back(skins.size());
++ const auto boneCount = sourceScene->mMeshes[i]->mNumBones;
++ auto bones = sourceScene->mMeshes[i]->mBones;
++ skins.push_back(SceneInfo::skinData{ bones, boneCount, nullptr });
++
++ // For skinning, we need to get the joints list and their target nodes.
++ // It is also done by the string based mapping and many of them will
++ // be animated. So we will use existing AnimationNodeMap for the data.
++ for (It j = 0; j != boneCount; ++j) {
++ const auto &nodeName = bones[j]->mName;
++ if (nodeName.length > 0) {
++ animatingNodes.insert(QByteArray{ nodeName.C_Str(),
++ qsizetype(nodeName.length) },
++ nullptr);
++ }
++ }
++ } else {
++ mesh2skin.push_back(-1);
++ }
++ }
++
++ for (It i = 0; i != embeddedTextureCount; ++i)
++ embeddedTextures.push_back(nullptr);
++
++ SceneInfo::TextureMap textureMap;
++
++ if (!targetScene.root) {
++ auto root = new QSSGSceneDesc::Node(QByteArrayLiteral("Root"), QSSGSceneDesc::Node::Type::Transform, QSSGSceneDesc::Node::RuntimeType::Node);
++ QSSGSceneDesc::addNode(targetScene, *root);
++ }
++
++ // Get Options
++ auto opt = processSceneOptions(options);
++ // check if the asset is GLTF format
++ const auto extension = sourceFile.suffix().toLower();
++ if (extension == QStringLiteral("gltf") || extension == QStringLiteral("glb"))
++ opt.gltfMode = true;
++ else if (extension == QStringLiteral("fbx"))
++ opt.fbxMode = true;
++
++ SceneInfo sceneInfo { *sourceScene, materials, meshes, embeddedTextures,
++ textureMap, skins, mesh2skin, sourceFile.dir(), opt };
++
++ if (!qFuzzyCompare(opt.globalScaleValue, 1.0f) && !qFuzzyCompare(opt.globalScaleValue, 0.0f)) {
++ const auto gscale = opt.globalScaleValue;
++ QSSGSceneDesc::setProperty(*targetScene.root, "scale", &QQuick3DNode::setScale, QVector3D { gscale, gscale, gscale });
++ }
++
++ // Now lets go through the scene
++ if (sourceScene->mRootNode)
++ processNode(sceneInfo, *sourceScene->mRootNode, *targetScene.root, nodeMap, animatingNodes);
++ // skins
++ for (It i = 0, endI = skins.size(); i != endI; ++i) {
++ const auto &skin = skins[i];
++
++ // It is possible that an asset has a unused mesh with a skin
++ if (!skin.node)
++ continue;
++
++ QList<QMatrix4x4> inverseBindPoses;
++ QVarLengthArray<QSSGSceneDesc::Node *> joints;
++ joints.reserve(skin.mNumBones);
++ for (It j = 0, endJ = skin.mNumBones; j != endJ; ++j) {
++ const auto &bone = *skin.mBones[j];
++ const auto &nodeName = bone.mName;
++ if (nodeName.length > 0) {
++ auto targetNode = animatingNodes.value(QByteArray{ nodeName.C_Str(), qsizetype(nodeName.length) });
++ joints.push_back(targetNode);
++ const auto &osMat = bone.mOffsetMatrix;
++ auto pose = QMatrix4x4(osMat[0][0], osMat[0][1], osMat[0][2], osMat[0][3],
++ osMat[1][0], osMat[1][1], osMat[1][2], osMat[1][3],
++ osMat[2][0], osMat[2][1], osMat[2][2], osMat[2][3],
++ osMat[3][0], osMat[3][1], osMat[3][2], osMat[3][3]);
++ inverseBindPoses.push_back(pose);
++ }
++ }
++ QSSGSceneDesc::setProperty(*skin.node, "joints", &QQuick3DSkin::joints, joints);
++ QSSGSceneDesc::setProperty(*skin.node, "inverseBindPoses", &QQuick3DSkin::setInverseBindPoses, inverseBindPoses);
++ }
++
++ static const auto fuzzyComparePos = [](const aiVectorKey *pos, const aiVectorKey *prev){
++ if (!prev)
++ return false;
++ return qFuzzyCompare(pos->mValue.x, prev->mValue.x)
++ && qFuzzyCompare(pos->mValue.y, prev->mValue.y)
++ && qFuzzyCompare(pos->mValue.z, prev->mValue.z);
++ };
++
++ static const auto fuzzyCompareRot = [](const aiQuatKey *rot, const aiQuatKey *prev){
++ if (!prev)
++ return false;
++ return qFuzzyCompare(rot->mValue.x, prev->mValue.x)
++ && qFuzzyCompare(rot->mValue.y, prev->mValue.y)
++ && qFuzzyCompare(rot->mValue.z, prev->mValue.z)
++ && qFuzzyCompare(rot->mValue.w, prev->mValue.w);
++ };
++
++ static const auto createAnimation = [](QSSGSceneDesc::Scene &targetScene, const aiAnimation &srcAnim, const AnimationNodeMap &animatingNodes) {
++ using namespace QSSGSceneDesc;
++ Animation targetAnimation;
++ auto &channels = targetAnimation.channels;
++ qreal freq = qFuzzyIsNull(srcAnim.mTicksPerSecond) ? 1.0
++ : 1000.0 / srcAnim.mTicksPerSecond;
++ targetAnimation.framesPerSecond = srcAnim.mTicksPerSecond;
++ targetAnimation.name = fromAiString(srcAnim.mName);
++ // Process property channels
++ for (It i = 0, end = srcAnim.mNumChannels; i != end; ++i) {
++ const auto &srcChannel = *srcAnim.mChannels[i];
++
++ const auto &nodeName = srcChannel.mNodeName;
++ if (nodeName.length > 0) {
++ const auto aNodeEnd = animatingNodes.cend();
++ const auto aNodeIt = animatingNodes.constFind(QByteArray{ nodeName.C_Str(), qsizetype(nodeName.length) });
++ if (aNodeIt != aNodeEnd && aNodeIt.value() != nullptr) {
++ auto targetNode = aNodeIt.value();
++ // Target propert[y|ies]
++
++ const auto currentPropertyValue = [targetNode](const char *propertyName) -> QVariant {
++ for (const auto *p : std::as_const(targetNode->properties)) {
++ if (!qstrcmp(propertyName, p->name))
++ return p->value;
++ }
++ return {};
++ };
++
++ { // Position
++ const auto posKeyEnd = srcChannel.mNumPositionKeys;
++ Animation::Channel targetChannel;
++ targetChannel.targetProperty = Animation::Channel::TargetProperty::Position;
++ targetChannel.target = targetNode;
++ const aiVectorKey *prevPos = nullptr;
++ for (It posKeyIdx = 0; posKeyIdx != posKeyEnd; ++posKeyIdx) {
++ const auto &posKey = srcChannel.mPositionKeys[posKeyIdx];
++ if (fuzzyComparePos(&posKey, prevPos))
++ continue;
++ targetChannel.keys.push_back(new Animation::KeyPosition(toAnimationKey(posKey, freq)));
++ prevPos = &posKey;
++ }
++
++ const auto isUnchanged = [&targetChannel, currentPropertyValue]() {
++ if (targetChannel.keys.count() != 1)
++ return false;
++ auto currentPos = currentPropertyValue("position").value<QVector3D>();
++ return qFuzzyCompare(targetChannel.keys[0]->value.toVector3D(), currentPos);
++ };
++ if (!targetChannel.keys.isEmpty()) {
++ if (!isUnchanged()) {
++ channels.push_back(new Animation::Channel(targetChannel));
++ float endTime = float(srcChannel.mPositionKeys[posKeyEnd - 1].mTime) * freq;
++ if (targetAnimation.length < endTime)
++ targetAnimation.length = endTime;
++ } else {
++ // the keys will not be used.
++ qDeleteAll(targetChannel.keys);
++ }
++ }
++ }
++
++ { // Rotation
++ const auto rotKeyEnd = srcChannel.mNumRotationKeys;
++ Animation::Channel targetChannel;
++ targetChannel.targetProperty = Animation::Channel::TargetProperty::Rotation;
++ targetChannel.target = targetNode;
++ const aiQuatKey *prevRot = nullptr;
++ for (It rotKeyIdx = 0; rotKeyIdx != rotKeyEnd; ++rotKeyIdx) {
++ const auto &rotKey = srcChannel.mRotationKeys[rotKeyIdx];
++ if (fuzzyCompareRot(&rotKey, prevRot))
++ continue;
++ targetChannel.keys.push_back(new Animation::KeyPosition(toAnimationKey(rotKey, freq)));
++ prevRot = &rotKey;
++ }
++
++ const auto isUnchanged = [&targetChannel, currentPropertyValue]() {
++ if (targetChannel.keys.count() != 1)
++ return false;
++ auto currentVal = currentPropertyValue("rotation");
++ QQuaternion rot = currentVal.isValid() ? currentVal.value<QQuaternion>() : QQuaternion{};
++ return qFuzzyCompare(QQuaternion(targetChannel.keys[0]->value), rot);
++ };
++ if (!targetChannel.keys.isEmpty()) {
++ if (!isUnchanged()) {
++ channels.push_back(new Animation::Channel(targetChannel));
++ float endTime = float(srcChannel.mRotationKeys[rotKeyEnd - 1].mTime) * freq;
++ if (targetAnimation.length < endTime)
++ targetAnimation.length = endTime;
++ } else {
++ // the keys will not be used.
++ qDeleteAll(targetChannel.keys);
++ }
++ }
++ }
++
++ { // Scale
++ const auto scaleKeyEnd = srcChannel.mNumScalingKeys;
++ Animation::Channel targetChannel;
++ targetChannel.targetProperty = Animation::Channel::TargetProperty::Scale;
++ targetChannel.target = targetNode;
++ const aiVectorKey *prevScale = nullptr;
++ for (It scaleKeyIdx = 0; scaleKeyIdx != scaleKeyEnd; ++scaleKeyIdx) {
++ const auto &scaleKey = srcChannel.mScalingKeys[scaleKeyIdx];
++ if (fuzzyComparePos(&scaleKey, prevScale))
++ continue;
++ targetChannel.keys.push_back(new Animation::KeyPosition(toAnimationKey(scaleKey, freq)));
++ prevScale = &scaleKey;
++ }
++
++ const auto isUnchanged = [&targetChannel, currentPropertyValue]() {
++ if (targetChannel.keys.count() != 1)
++ return false;
++ auto currentVal = currentPropertyValue("scale");
++ QVector3D scale = currentVal.isValid() ? currentVal.value<QVector3D>() : QVector3D{ 1, 1, 1 };
++ return qFuzzyCompare(targetChannel.keys[0]->value.toVector3D(), scale);
++ };
++
++ if (!targetChannel.keys.isEmpty()) {
++ if (!isUnchanged()) {
++ channels.push_back(new Animation::Channel(targetChannel));
++ float endTime = float(srcChannel.mScalingKeys[scaleKeyEnd - 1].mTime) * freq;
++ if (targetAnimation.length < endTime)
++ targetAnimation.length = endTime;
++ } else {
++ // the keys will not be used.
++ qDeleteAll(targetChannel.keys);
++ }
++ }
++ }
++ }
++ }
++ }
++ // Morphing Animations
++ for (It i = 0, end = srcAnim.mNumMorphMeshChannels; i != end; ++i) {
++ const auto &srcMorphChannel = *srcAnim.mMorphMeshChannels[i];
++ const QString nodeName(srcMorphChannel.mName.C_Str());
++ const auto *morphKeys = srcMorphChannel.mKeys;
++ const auto numMorphTargets = qMin(morphKeys[0].mNumValuesAndWeights, 8U);
++ for (It targetId = 0; targetId != numMorphTargets; ++targetId) {
++ QString morphTargetName = nodeName + QStringLiteral("_morph") + QString::number(targetId);
++ const auto aNodeEnd = animatingNodes.cend();
++ const auto aNodeIt = animatingNodes.constFind(morphTargetName.toUtf8());
++ if (aNodeIt != aNodeEnd && aNodeIt.value() != nullptr) {
++ auto targetNode = aNodeIt.value();
++ const auto weightKeyEnd = srcMorphChannel.mNumKeys;
++ Animation::Channel targetChannel;
++ targetChannel.targetProperty = Animation::Channel::TargetProperty::Weight;
++ targetChannel.target = targetNode;
++ for (It wId = 0; wId != weightKeyEnd; ++wId) {
++ const auto &weightKey = srcMorphChannel.mKeys[wId];
++ const auto animationKey = new Animation::KeyPosition(toAnimationKey(weightKey, freq, targetId));
++ targetChannel.keys.push_back(animationKey);
++ }
++ if (!targetChannel.keys.isEmpty()) {
++ channels.push_back(new Animation::Channel(targetChannel));
++ float endTime = float(srcMorphChannel.mKeys[weightKeyEnd - 1].mTime) * freq;
++ if (targetAnimation.length < endTime)
++ targetAnimation.length = endTime;
++ }
++ }
++ }
++ }
++
++ // If we have data we need to make it persistent.
++ if (!targetAnimation.channels.isEmpty())
++ targetScene.animations.push_back(new Animation(targetAnimation));
++ };
++
++ // All scene nodes should now be created (and ready), so let's go through the animation data.
++ if (sourceScene->HasAnimations()) {
++ const auto animationCount = sourceScene->mNumAnimations;
++ targetScene.animations.reserve(animationCount);
++ for (It i = 0, end = animationCount; i != end; ++i) {
++ const auto &srcAnim = *sourceScene->mAnimations[i];
++ createAnimation(targetScene, srcAnim, animatingNodes);
++ }
++ }
++
++ // TODO, FIX: Editing the scene after the import ought to be done by QSSGAssetImportManager
++ // and not by the asset import plugin. However, the asset import module cannot use
++ // the asset utils module because that would cause a circular dependency. This
++ // needs a deeper architectural fix.
++
++ QSSGQmlUtilities::applyEdit(&targetScene, options);
++
++ return QString();
++ }
++
++ ////////////////////////
++
++ QString AssimpImporter::import(const QUrl &url, const QJsonObject &options, QSSGSceneDesc::Scene &scene)
++ {
++ // We'll simply use assimp to load the scene and then translate the Aassimp scene
++ // into our own format.
++ return importImp(url, options, scene);
++ }
++
++ QString AssimpImporter::import(const QString &sourceFile, const QDir &savePath, const QJsonObject &options, QStringList *generatedFiles)
++ {
++ QString errorString;
++
++ QSSGSceneDesc::Scene scene;
++
++ // Load scene data
++ auto sourceUrl = QUrl::fromLocalFile(sourceFile);
++ errorString = importImp(sourceUrl, options, scene);
++
++ if (!errorString.isEmpty())
++ return errorString;
++
++ // Write out QML + Resources
++ QFileInfo sourceFileInfo(sourceFile);
++
++ QString targetFileName = savePath.absolutePath() + QDir::separator() +
++ QSSGQmlUtilities::qmlComponentName(sourceFileInfo.completeBaseName()) +
++ QStringLiteral(".qml");
++ QFile targetFile(targetFileName);
++ if (!targetFile.open(QIODevice::WriteOnly)) {
++ errorString += QString("Could not write to file: ") + targetFileName;
++ } else {
++ QTextStream output(&targetFile);
++ QSSGQmlUtilities::writeQml(scene, output, savePath, options);
++ if (generatedFiles)
++ generatedFiles->append(targetFileName);
++ }
++ scene.cleanup();
++
++ return errorString;
++ }
++
++ QT_END_NAMESPACE