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 "qquick3dresourceloader_p.h"
++ #include "qquick3dmodel_p.h"
++ #include <QtQuick3DRuntimeRender/private/qssgrenderresourceloader_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \qmltype ResourceLoader
++ \inqmlmodule QtQuick3D
++ \inherits Object3D
++
++ \brief Allows pre-loading of 3D resources.
++
++ ResourceLoader is used to pre-load resources for Qt Quick 3D. Normally
++ resources are only loaded when they are needed to render a frame, and are
++ unloaded when they are not used to render the scene. This aggressive
++ approach to resource lifetimes means that only the bare minimum of GPU
++ resources are used to render a frame, but for some dynamic scenes this
++ can lead to resources being loaded and released frequently. The
++ ResourceLoader component enables a finer grain control on the lifetimes
++ of resources in the scene. Resources listed in the ResourceLoader
++ component are loaded into GPU memory and will remain there until they
++ are removed from the ResourceLoader lists or the ResourceLoader is
++ destroyed.
++
++ ResourceLoader can also be used to make sure that large resources are
++ available before rendering a frame. Since resources are loaded only
++ when needed for a frame, this can lead to frames being dropped waiting
++ for a large resource to be loaded. By pre-loading large resources before
++ showing a scene, there is no risk of dropping any frames due to resources
++ being loaded during an animation.
++
++ For usage examples, see \l {Qt Quick 3D - Principled Material Example}
++
++ */
++
++ /*!
++ \qmlproperty List<url> ResourceLoader::meshSources
++
++ This property defines a list of locations of mesh files containing geometry.
++ When a mesh file is added to this list, it will be loaded to the GPU and
++ cached. If these same mesh files are source is used by a /c Model they will
++ not need to be loaded again.
++
++ */
++
++ /*!
++ \qmlproperty List<QtQuick3D::Texture> ResourceLoader::textures
++
++ This property defines a list of Texture resources that will be loaded to the
++ GPU and cached.
++
++ */
++
++ /*!
++ \qmlproperty List<QtQuick3D::Geometry> ResourceLoader::geometries
++
++ This property defines a list of Geometry resources that will be loaded to the
++ GPU and cached.
++
++ */
++
++ QQuick3DResourceLoader::QQuick3DResourceLoader(QQuick3DObject *parent)
++ : QQuick3DObject(*(new QQuick3DObjectPrivate(QQuick3DObjectPrivate::Type::ResourceLoader)), parent)
++ {
++ }
++
++ const QList<QUrl> &QQuick3DResourceLoader::meshSources() const
++ {
++ return m_meshSources;
++ }
++
++ void QQuick3DResourceLoader::setMeshSources(const QList<QUrl> &newMeshSources)
++ {
++ if (m_meshSources == newMeshSources)
++ return;
++ m_meshSources = newMeshSources;
++ emit meshSourcesChanged();
++ markDirty(QQuick3DResourceLoader::MeshesDirty);
++ }
++
++
++ QQmlListProperty<QQuick3DGeometry> QQuick3DResourceLoader::geometries()
++ {
++ return QQmlListProperty<QQuick3DGeometry>(this,
++ nullptr,
++ QQuick3DResourceLoader::qmlAppendGeometry,
++ QQuick3DResourceLoader::qmlGeometriesCount,
++ QQuick3DResourceLoader::qmlGeometryAt,
++ QQuick3DResourceLoader::qmlClearGeometries);
++ }
++
++ QQmlListProperty<QQuick3DTexture> QQuick3DResourceLoader::textures()
++ {
++ return QQmlListProperty<QQuick3DTexture>(this,
++ nullptr,
++ QQuick3DResourceLoader::qmlAppendTexture,
++ QQuick3DResourceLoader::qmlTexturesCount,
++ QQuick3DResourceLoader::qmlTextureAt,
++ QQuick3DResourceLoader::qmlClearTextures);
++ }
++
++ void QQuick3DResourceLoader::onGeometryDestroyed(QObject *object)
++ {
++ bool found = false;
++ for (int i = 0; i < m_geometries.size(); ++i) {
++ if (m_geometries[i] == object) {
++ m_geometries.removeAt(i--);
++ found = true;
++ }
++ }
++ if (found)
++ markDirty(QQuick3DResourceLoader::GeometriesDirty);
++ }
++
++ void QQuick3DResourceLoader::onTextureDestroyed(QObject *object)
++ {
++ bool found = false;
++ for (int i = 0; i < m_textures.size(); ++i) {
++ if (m_textures[i] == object) {
++ m_textures.removeAt(i--);
++ found = true;
++ }
++ }
++ if (found)
++ markDirty(QQuick3DResourceLoader::TexturesDirty);
++ }
++
++ QSSGRenderGraphObject *QQuick3DResourceLoader::updateSpatialNode(QSSGRenderGraphObject *node)
++ {
++ if (!node) {
++ markAllDirty();
++ node = new QSSGRenderResourceLoader();
++ }
++ QQuick3DObject::updateSpatialNode(node);
++ int dirtyAttribute = 0;
++
++ auto resourceLoaderNode = static_cast<QSSGRenderResourceLoader *>(node);
++ if (m_dirtyAttributes & MeshesDirty) {
++ resourceLoaderNode->meshes.clear();
++ for (const auto &mesh : std::as_const(m_meshSources))
++ resourceLoaderNode->meshes.push_back(QSSGRenderPath(QQuick3DModel::translateMeshSource(mesh, this)));
++ }
++
++ if (m_dirtyAttributes & TexturesDirty) {
++ resourceLoaderNode->textures.clear();
++ for (const auto &texture : std::as_const(m_textures)) {
++ auto graphObject = QQuick3DObjectPrivate::get(texture)->spatialNode;
++ if (graphObject)
++ resourceLoaderNode->textures.push_back(graphObject);
++ else
++ dirtyAttribute |= TexturesDirty;
++ }
++ }
++
++ if (m_dirtyAttributes & GeometriesDirty) {
++ resourceLoaderNode->geometries.clear();
++ for (const auto &geometry : std::as_const(m_geometries)) {
++ auto graphObject = QQuick3DObjectPrivate::get(geometry)->spatialNode;
++ if (graphObject)
++ resourceLoaderNode->geometries.push_back(graphObject);
++ else
++ dirtyAttribute |= GeometriesDirty;
++ }
++ }
++
++ m_dirtyAttributes = dirtyAttribute;
++ return resourceLoaderNode;
++
++ }
++
++ void QQuick3DResourceLoader::markAllDirty()
++ {
++ m_dirtyAttributes = 0xffffffff;
++ QQuick3DObject::markAllDirty();
++ }
++
++ void QQuick3DResourceLoader::itemChange(ItemChange change, const ItemChangeData &value)
++ {
++ if (change == QQuick3DObject::ItemSceneChange)
++ updateSceneManager(value.sceneManager);
++ }
++
++ void QQuick3DResourceLoader::qmlAppendGeometry(QQmlListProperty<QQuick3DGeometry> *list, QQuick3DGeometry *geometry)
++ {
++ if (geometry == nullptr)
++ return;
++ QQuick3DResourceLoader *self = static_cast<QQuick3DResourceLoader *>(list->object);
++ self->m_geometries.push_back(geometry);
++
++ self->markDirty(QQuick3DResourceLoader::GeometriesDirty);
++
++ if (geometry->parentItem() == nullptr) {
++ // If the material has no parent, check if it has a hierarchical parent that's a QQuick3DObject
++ // and re-parent it to that, e.g., inline materials
++ QQuick3DObject *parentItem = qobject_cast<QQuick3DObject *>(geometry->parent());
++ if (parentItem) {
++ geometry->setParentItem(parentItem);
++ } else { // If no valid parent was found, make sure the material refs our scene manager
++ const auto &sceneManager = QQuick3DObjectPrivate::get(self)->sceneManager;
++ if (sceneManager) {
++ QQuick3DObjectPrivate::get(geometry)->refSceneManager(*sceneManager);
++ }
++ }
++ }
++
++ // Make sure geometries are removed when destroyed
++ connect(geometry, &QQuick3DGeometry::destroyed, self, &QQuick3DResourceLoader::onGeometryDestroyed);
++ }
++
++ QQuick3DGeometry *QQuick3DResourceLoader::qmlGeometryAt(QQmlListProperty<QQuick3DGeometry> *list, qsizetype index)
++ {
++ QQuick3DResourceLoader *self = static_cast<QQuick3DResourceLoader *>(list->object);
++
++ if (index >= self->m_geometries.size()) {
++ qWarning("The index exceeds the range of valid geometries.");
++ return nullptr;
++ }
++
++ return self->m_geometries.at(index);
++ }
++
++ qsizetype QQuick3DResourceLoader::qmlGeometriesCount(QQmlListProperty<QQuick3DGeometry> *list)
++ {
++ QQuick3DResourceLoader *self = static_cast<QQuick3DResourceLoader *>(list->object);
++ return self->m_geometries.size();
++ }
++
++ void QQuick3DResourceLoader::qmlClearGeometries(QQmlListProperty<QQuick3DGeometry> *list)
++ {
++ QQuick3DResourceLoader *self = static_cast<QQuick3DResourceLoader *>(list->object);
++ for (const auto &geometry : std::as_const(self->m_geometries)) {
++ if (geometry->parentItem() == nullptr)
++ QQuick3DObjectPrivate::get(geometry)->derefSceneManager();
++ disconnect(geometry, &QQuick3DGeometry::destroyed, self, &QQuick3DResourceLoader::onGeometryDestroyed);
++ }
++
++ self->m_geometries.clear();
++ self->markDirty(QQuick3DResourceLoader::GeometriesDirty);
++ }
++
++ void QQuick3DResourceLoader::qmlAppendTexture(QQmlListProperty<QQuick3DTexture> *list, QQuick3DTexture *texture)
++ {
++ if (texture == nullptr)
++ return;
++ QQuick3DResourceLoader *self = static_cast<QQuick3DResourceLoader *>(list->object);
++ self->m_textures.push_back(texture);
++
++ self->markDirty(QQuick3DResourceLoader::TexturesDirty);
++
++ if (texture->parentItem() == nullptr) {
++ // If the material has no parent, check if it has a hierarchical parent that's a QQuick3DObject
++ // and re-parent it to that, e.g., inline materials
++ QQuick3DObject *parentItem = qobject_cast<QQuick3DObject *>(texture->parent());
++ if (parentItem) {
++ texture->setParentItem(parentItem);
++ } else { // If no valid parent was found, make sure the material refs our scene manager
++ const auto &sceneManager = QQuick3DObjectPrivate::get(self)->sceneManager;
++ if (sceneManager) {
++ QQuick3DObjectPrivate::get(texture)->refSceneManager(*sceneManager);
++ }
++ }
++ }
++ // Make sure TextureData are removed when destroyed
++ connect(texture, &QQuick3DTextureData::destroyed, self, &QQuick3DResourceLoader::onTextureDestroyed);
++ }
++
++ QQuick3DTexture *QQuick3DResourceLoader::qmlTextureAt(QQmlListProperty<QQuick3DTexture> *list, qsizetype index)
++ {
++ QQuick3DResourceLoader *self = static_cast<QQuick3DResourceLoader *>(list->object);
++ if (index >= self->m_textures.size()) {
++ qWarning("The index exceeds the range of valid texture data.");
++ return nullptr;
++ }
++
++ return self->m_textures.at(index);
++ }
++
++ qsizetype QQuick3DResourceLoader::qmlTexturesCount(QQmlListProperty<QQuick3DTexture> *list)
++ {
++ QQuick3DResourceLoader *self = static_cast<QQuick3DResourceLoader *>(list->object);
++ return self->m_textures.size();
++ }
++
++ void QQuick3DResourceLoader::qmlClearTextures(QQmlListProperty<QQuick3DTexture> *list)
++ {
++ QQuick3DResourceLoader *self = static_cast<QQuick3DResourceLoader *>(list->object);
++ for (const auto &data : std::as_const(self->m_textures)) {
++ if (data->parentItem() == nullptr)
++ QQuick3DObjectPrivate::get(data)->derefSceneManager();
++ disconnect(data, &QQuick3DTextureData::destroyed, self, &QQuick3DResourceLoader::onTextureDestroyed);
++ }
++ self->m_textures.clear();
++ self->markDirty(QQuick3DResourceLoader::TexturesDirty);
++ }
++
++ void QQuick3DResourceLoader::markDirty(ResourceLoaderDirtyType type)
++ {
++ if (!(m_dirtyAttributes & quint32(type))) {
++ m_dirtyAttributes |= quint32(type);
++ update();
++ }
++ }
++
++ void QQuick3DResourceLoader::updateSceneManager(QQuick3DSceneManager *sceneManager)
++ {
++ if (sceneManager) {
++ for (auto &geometry : m_geometries)
++ if (!geometry->parentItem() && !QQuick3DObjectPrivate::get(geometry)->sceneManager)
++ QQuick3DObjectPrivate::refSceneManager(geometry, *sceneManager);
++ for (auto &texture : m_textures)
++ if (!texture->parentItem() && !QQuick3DObjectPrivate::get(texture)->sceneManager)
++ QQuick3DObjectPrivate::refSceneManager(texture, *sceneManager);
++ } else {
++ for (auto &geometry : m_geometries)
++ QQuick3DObjectPrivate::derefSceneManager(geometry);
++ for (auto &texture : m_textures)
++ QQuick3DObjectPrivate::derefSceneManager(texture);
++ }
++ }
++
++ QT_END_NAMESPACE