qquick3druntimeloader.cpp

Go to the documentation of this file.

// 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 "qquick3druntimeloader_p.h"
 
#include <QtQuick3DAssetUtils/private/qssgscenedesc_p.h>
#include <QtQuick3DAssetUtils/private/qssgqmlutilities_p.h>
#include <QtQuick3DAssetUtils/private/qssgrtutilities_p.h>
#include <QtQuick3DAssetImport/private/qssgassetimportmanager_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderbuffermanager_p.h>
#if QT_CONFIG(mimetype)
#include <QtCore/qmimedatabase.h>
#endif
 
/*!
    \qmltype RuntimeLoader
    \inherits Node
    \inqmlmodule QtQuick3D.AssetUtils
    \since 6.2
    \brief Imports a 3D asset at runtime.
 
    The RuntimeLoader type provides a way to load a 3D asset directly from source at runtime,
    without converting it to QtQuick3D's internal format first.
 
    RuntimeLoader supports .obj and glTF version 2.0 files in both in text (.gltf) and binary
    (.glb) formats.
 
    glTF assets are loaded by the native glTF importer; see
    \l{Balsam Asset Import Tool} for the supported feature set and
    extensions. Setting the \c{QT_QUICK3D_DISABLE_NATIVE_GLTF} environment
    variable routes glTF assets through the Assimp importer instead during
    the transition period.
 
    \warning RuntimeLoader does not sandbox or validate asset contents. Loading
    malformed or untrusted assets may have security implications. See \l source
    for details.
*/
 
/*!
    \qmlenum RuntimeLoader::QueryFilter
 
    Specifies the type of objects to query for.
 
    \value Textures Query for texture objects
    \value Materials Query for material objects
    \value Nodes Query for node objects
    \value Cameras Query for camera objects
    \value Lights Query for light objects
    \value Models Query for model objects
 
 
    \sa queryAll()
*/
 
/*!
    \qmlproperty url RuntimeLoader::source
 
    This property holds the location of the source file containing the 3D asset.
    Changing this property will unload the current asset and attempt to load an asset from
    the given URL.
 
    The success or failure of the load operation is indicated by \l status.
 
    \warning RuntimeLoader does not sandbox or validate asset contents. Loading
    malformed or untrusted assets may have security implications. Application
    developers should carefully consider these before allowing the loading of
    user-provided content that is not part of the application.
*/
 
/*!
    \qmlproperty enumeration RuntimeLoader::status
 
    This property holds the status of the latest load operation.
 
    \value RuntimeLoader.Empty
        No URL was specified.
    \value RuntimeLoader.Success
        The load operation was successful.
    \value RuntimeLoader.Error
        The load operation failed. A human-readable error message is provided by \l errorString.
 
    \readonly
*/
 
/*!
    \qmlproperty string RuntimeLoader::errorString
 
    This property holds a human-readable string indicating the status of the latest load operation.
 
    \readonly
*/
 
/*!
    \qmlproperty Bounds RuntimeLoader::bounds
 
    This property describes the extents of the bounding volume around the imported model.
 
    \note The value may not be available before the first render
 
    \readonly
*/
 
/*!
    \qmlproperty Instancing RuntimeLoader::instancing
 
    If this property is set, the imported model will not be rendered normally. Instead, a number of
    instances will be rendered, as defined by the instance table.
 
    See the \l{Instanced Rendering} overview documentation for more information.
*/
 
QT_BEGIN_NAMESPACE
 
QQuick3DRuntimeLoader::QQuick3DRuntimeLoader(QQuick3DNode *parent)
    : QQuick3DNode(parent)
{
 
}
 
QUrl QQuick3DRuntimeLoader::source() const
{
    return m_source;
}
 
void QQuick3DRuntimeLoader::setSource(const QUrl &newSource)
{
    if (m_source == newSource)
        return;
 
    const QQmlContext *context = qmlContext(this);
    auto resolvedUrl = (context ? context->resolvedUrl(newSource) : newSource);
 
    if (m_source == resolvedUrl)
        return;
 
    m_source = resolvedUrl;
    emit sourceChanged();
 
    if (isComponentComplete())
        loadSource();
}
 
void QQuick3DRuntimeLoader::componentComplete()
{
    QQuick3DNode::componentComplete();
    loadSource();
}
 
QStringList QQuick3DRuntimeLoader::supportedExtensions()
{
    static QStringList extensions;
    if (!extensions.isEmpty())
        return extensions;
 
    static const QStringList supportedExtensions = { QLatin1StringView("obj"),
                                                     QLatin1StringView("gltf"),
                                                     QLatin1StringView("glb")};
 
    QSSGAssetImportManager importManager;
    const auto types = importManager.getImporterPluginInfos();
 
    for (const auto &t : types) {
        for (const QString &extension : t.inputExtensions) {
            // Several plugins can claim the same extension
            if (supportedExtensions.contains(extension) && !extensions.contains(extension))
                extensions << extension;
        }
    }
    return extensions;
}
 
#if QT_CONFIG(mimetype)
QList<QMimeType> QQuick3DRuntimeLoader::supportedMimeTypes()
{
    static QList<QMimeType> mimeTypes;
    if (!mimeTypes.isEmpty())
        return mimeTypes;
 
    const QStringList &extensions = supportedExtensions();
 
    QMimeDatabase db;
    for (const auto &ext : extensions) {
        // TODO: Change to db.mimeTypesForExtension(ext), once it is implemented (QTBUG-118566)
        const QString fileName = QLatin1StringView("test.") + ext;
        mimeTypes << db.mimeTypesForFileName(fileName);
    }
 
    return mimeTypes;
}
#endif
 
static void boxBoundsRecursive(const QQuick3DNode *baseNode, const QQuick3DNode *node, QQuick3DBounds3 &accBounds)
{
    if (!node)
        return;
 
    if (auto *model = qobject_cast<const QQuick3DModel *>(node)) {
        auto b = model->bounds();
        for (const QVector3D point : b.bounds.toQSSGBoxPoints()) {
            auto p = model->mapPositionToNode(const_cast<QQuick3DNode *>(baseNode), point);
            if (Q_UNLIKELY(accBounds.bounds.isEmpty()))
                accBounds.bounds = { p, p };
            else
                accBounds.bounds.include(p);
        }
    }
    const auto childItems1 = node->childItems();
    for (auto *child : childItems1)
        boxBoundsRecursive(baseNode, qobject_cast<const QQuick3DNode *>(child), accBounds);
}
 
template<typename Func>
static void applyToModels(QQuick3DObject *obj, Func &&lambda)
{
    if (!obj)
        return;
    const auto childItems2 = obj->childItems();
    for (auto *child : childItems2) {
        if (auto *model = qobject_cast<QQuick3DModel *>(child))
            lambda(model);
        applyToModels(child, lambda);
    }
}
 
void QQuick3DRuntimeLoader::loadSource()
{
    delete m_root;
    m_objects.clear();
    m_objectsByType.clear();
    const bool hadVariants = !m_materialVariants.isEmpty();
    m_materialVariants.clear();
    m_variantModels.clear();
    if (hadVariants)
        emit materialVariantsChanged();
    QSSGBufferManager::unregisterMeshData(m_assetId);
 
    m_status = Status::Empty;
    m_errorString = QStringLiteral("No file selected");
    if (!m_source.isValid()) {
        emit statusChanged();
        emit errorStringChanged();
        return;
    }
 
    QSSGAssetImportManager importManager;
    QSSGSceneDesc::Scene scene;
    QString error(QStringLiteral("Unknown error"));
    auto result = importManager.importFile(m_source, scene, &error);
 
    switch (result) {
    case QSSGAssetImportManager::ImportState::Success:
        m_errorString = QStringLiteral("Success!");
        m_status = Status::Success;
        break;
    case QSSGAssetImportManager::ImportState::IoError:
        m_errorString = QStringLiteral("IO Error: ") + error;
        m_status = Status::Error;
        break;
    case QSSGAssetImportManager::ImportState::Unsupported:
        m_errorString = QStringLiteral("Unsupported: ") + error;
        m_status = Status::Error;
        break;
    }
 
    if (m_status == Status::Success) {
        // We create a dummy root node here, as it will be the parent to the first-level nodes
        // and resources. If we use 'this' those first-level nodes/resources won't be deleted
        // when a new scene is loaded.
        m_root = new QQuick3DNode(this);
        m_root->setObjectName("RuntimeLoaderRoot");
        m_imported = QSSGRuntimeUtils::createScene(*m_root, scene, &m_objects, &m_objectsByType);
        m_assetId = scene.id;
        m_boundsDirty = true;
        m_instancingChanged = m_instancing != nullptr;
 
        // Material variant tables have to be collected before cleanup()
        m_materialVariants = scene.materialVariants;
        m_variantModels.clear();
        if (!m_materialVariants.isEmpty()) {
            const auto materialObjects = [](const QList<QSSGSceneDesc::Node *> &materials) {
                QList<QQuick3DMaterial *> result;
                result.reserve(materials.size());
                for (const QSSGSceneDesc::Node *material : materials)
                    result.append(qobject_cast<QQuick3DMaterial *>(material->obj));
                return result;
            };
            QList<QSSGSceneDesc::Node *> pending { scene.root };
            while (!pending.isEmpty()) {
                QSSGSceneDesc::Node *node = pending.takeLast();
                pending.append(node->children);
                if (node->nodeType != QSSGSceneDesc::Node::Type::Model)
                    continue;
                const auto &model = static_cast<const QSSGSceneDesc::Model &>(*node);
                if (model.variantMaterials.isEmpty())
                    continue;
                ModelVariantMaterials entry;
                entry.model = qobject_cast<QQuick3DModel *>(model.obj);
                entry.defaults = materialObjects(model.defaultMaterials);
                for (const auto &variantList : model.variantMaterials)
                    entry.perVariant.append(materialObjects(variantList));
                m_variantModels.append(entry);
            }
        }
        emit materialVariantsChanged();
 
        updateModels();
        // Cleanup scene before deleting.
        scene.cleanup();
    } else {
        m_source.clear();
        emit sourceChanged();
    }
 
    emit statusChanged();
    emit errorStringChanged();
 
}
 
void QQuick3DRuntimeLoader::updateModels()
{
    if (m_instancingChanged) {
        applyToModels(m_imported, [this](QQuick3DModel *model) {
            model->setInstancing(m_instancing);
            model->setInstanceRoot(m_imported);
        });
        m_instancingChanged = false;
    }
    if (!m_variantModels.isEmpty())
        applyMaterialVariant();
}
 
void QQuick3DRuntimeLoader::applyMaterialVariant()
{
    const qsizetype variantIndex = m_materialVariants.indexOf(m_materialVariant);
    if (!m_materialVariant.isEmpty() && variantIndex < 0 && !m_materialVariants.isEmpty()) {
        qWarning() << "Asset has no material variant" << m_materialVariant
                   << "- available variants:" << m_materialVariants;
    }
    for (const ModelVariantMaterials &entry : std::as_const(m_variantModels)) {
        if (!entry.model)
            continue;
        const QList<QQuick3DMaterial *> &materials = (variantIndex >= 0 && variantIndex < entry.perVariant.size())
                ? entry.perVariant.at(variantIndex)
                : entry.defaults;
        QQmlListProperty<QQuick3DMaterial> list = entry.model->materials();
        list.clear(&list);
        for (QQuick3DMaterial *material : materials)
            list.append(&list, material);
    }
}
 
/*!
    \qmlproperty list<string> RuntimeLoader::materialVariants
    \readonly
    \since 6.13
 
    This property holds the names of the material variants defined by the
    loaded asset (for example glTF assets using the KHR_materials_variants
    extension). The list is empty when the asset defines no variants.
 
    \sa materialVariant
*/
QStringList QQuick3DRuntimeLoader::materialVariants() const
{
    return m_materialVariants;
}
 
/*!
    \qmlproperty string RuntimeLoader::materialVariant
    \since 6.13
 
    This property selects which of the loaded asset's material variants is
    applied to its models. Setting an empty string, or a name not present in
    \l materialVariants, applies the asset's default materials.
 
    \sa materialVariants
*/
QString QQuick3DRuntimeLoader::materialVariant() const
{
    return m_materialVariant;
}
 
void QQuick3DRuntimeLoader::setMaterialVariant(const QString &variant)
{
    if (m_materialVariant == variant)
        return;
    m_materialVariant = variant;
    if (!m_variantModels.isEmpty())
        applyMaterialVariant();
    emit materialVariantChanged();
}
 
QQuick3DRuntimeLoader::Status QQuick3DRuntimeLoader::status() const
{
    return m_status;
}
 
QString QQuick3DRuntimeLoader::errorString() const
{
    return m_errorString;
}
 
QSSGRenderGraphObject *QQuick3DRuntimeLoader::updateSpatialNode(QSSGRenderGraphObject *node)
{
    auto *result = QQuick3DNode::updateSpatialNode(node);
    if (m_boundsDirty)
        QMetaObject::invokeMethod(this, &QQuick3DRuntimeLoader::boundsChanged, Qt::QueuedConnection);
    return result;
}
 
void QQuick3DRuntimeLoader::calculateBounds()
{
    if (!m_imported || !m_boundsDirty)
        return;
 
    m_bounds.bounds.setEmpty();
    boxBoundsRecursive(m_imported, m_imported, m_bounds);
    m_boundsDirty = false;
}
 
const QQuick3DBounds3 &QQuick3DRuntimeLoader::bounds() const
{
    if (m_boundsDirty) {
        auto *that = const_cast<QQuick3DRuntimeLoader *>(this);
        that->calculateBounds();
        return that->m_bounds;
    }
 
    return m_bounds;
}
 
QQuick3DInstancing *QQuick3DRuntimeLoader::instancing() const
{
    return m_instancing;
}
 
void QQuick3DRuntimeLoader::setInstancing(QQuick3DInstancing *newInstancing)
{
    if (m_instancing == newInstancing)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DRuntimeLoader::setInstancing,
                                         newInstancing, m_instancing);
 
    m_instancing = newInstancing;
    m_instancingChanged = true;
    updateModels();
    emit instancingChanged();
}
 
/*!
    \qmlmethod Object3D RuntimeLoader::query(string arg)
    \since 6.12
 
    Returns the object with the given name, or \c null if no object with that name exists.
 
    The \a arg parameter is the name of the object to query or a query string.
    For example, to query the object named "PaintMaterialX", use the following code:
 
    \badcode
    var object = runtimeLoader.query("PaintMaterial")
    \endcode
 
    The above code works as expected assuming the objects are sensibly named in the source asset file.
    However, if there are multiple objects with the same name, the query will return the first object
    found matching the given name. To query a specific object, and avoid ambiguity, use the full object path.
 
    \badcode
    var object = runtimeLoader.query("/House2/Wall001/Mirror/Material")
    \endcode
 
    \note Even with paths it's possible for a improperly structured asset file to have multiple objects with the same path,
    as the paths are built up from the object names in the source asset file.
 
    \note The object names are defined as in the source asset file.
 
    \note A glTF node using \c EXT_mesh_gpu_instancing is imported as a Node
    carrying the node's transform, with the instanced Model as its child. The
    asset's name belongs to that Node, so querying such a node returns a Node
    rather than a Model. Use queryAll() with the \c Models filter to reach the
    Model itself.
*/
 
QQuick3DObject *QQuick3DRuntimeLoader::query(const QString &name) const
{
    const auto index = name.lastIndexOf(QChar(u'/'));
 
    if (index != -1) {
        const QString shortName = name.mid(index + 1);
        const auto range = m_objects.equal_range({shortName, QString()});
        for (auto it = range.first; it != range.second; ++it) {
            if (it.key().path == name)
                return it.value();
        }
    }
 
    return m_objects.value(QSSGRuntimeObjectNameKey{name, QString()});
}
 
static inline QSSGRenderGraphObject::BaseType queryFilterToBaseType(QQuick3DRuntimeLoader::QueryFilter filter)
{
    using Type = QSSGRenderGraphObject::Type;
    switch (filter) {
    case QQuick3DRuntimeLoader::QueryFilter::Textures:
        return QSSGRenderGraphObjectUtils::getBaseType(Type::Image2D);
    case QQuick3DRuntimeLoader::QueryFilter::Materials:
        return QSSGRenderGraphObjectUtils::getBaseType(Type::PrincipledMaterial);
    case QQuick3DRuntimeLoader::QueryFilter::Nodes:
        return QSSGRenderGraphObjectUtils::getBaseType(Type::Node);
    case QQuick3DRuntimeLoader::QueryFilter::Cameras:
        return QSSGRenderGraphObjectUtils::getBaseType(Type::OrthographicCamera);
    case QQuick3DRuntimeLoader::QueryFilter::Lights:
        return QSSGRenderGraphObjectUtils::getBaseType(Type::DirectionalLight);
    case QQuick3DRuntimeLoader::QueryFilter::Models:
        return QSSGRenderGraphObjectUtils::getBaseType(Type::Model);
    }
 
    Q_UNREACHABLE_RETURN(QSSGRenderGraphObject::BaseType(0));
}
 
/*!
    \qmlmethod List<Object3D> RuntimeLoader::queryAll(QueryFilter filter)
    \since 6.12
 
    Returns a list of all objects matching the given filter.
 
    The \a filter parameter specifies the type of objects to query for.
    For example, to query for all materials, use the following code:
 
    \badcode
    var materials = runtimeLoader.queryAll(RuntimeLoader.Materials)
    \endcode
 
    The above code returns a list of all materials in the source asset file.
*/
 
QList<QQuick3DObject *> QQuick3DRuntimeLoader::queryAll(QueryFilter filter) const
{
    QList<QQuick3DObject *> results;
    const auto range = m_objectsByType.equal_range(queryFilterToBaseType(filter));
    for (auto it = range.first; it != range.second; ++it) {
        if (auto *obj = it.value().data())
            results << obj;
    }
    return results;
}
 
QT_END_NAMESPACE