qquick3dmodel.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qquick3dmodel_p.h"
#include "qquick3dobject_p.h"
#include "qquick3dscenemanager_p.h"
#include "qquick3dnode_p_p.h"
#include "qquick3dinstancing_p.h"
 
#include <QtQuick3DRuntimeRender/private/qssgrendergraphobject_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrendercustommaterial_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderdefaultmaterial_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrendermodel_p.h>
 
#include <QtQuick3DUtils/private/qssgutils_p.h>
 
#include <QtQml/QQmlFile>
 
QT_BEGIN_NAMESPACE
 
QQuick3DModel::QQuick3DModel(QQuick3DNode *parent)
    : QQuick3DNode(*(new QQuick3DNodePrivate(QQuick3DNodePrivate::Type::Model)), parent) {}
 
QQuick3DModel::~QQuick3DModel()
{
    disconnect(m_geometryConnection);
 
    auto matList = materials();
    qmlClearMaterials(&matList);
    auto morphList = morphTargets();
    qmlClearMorphTargets(&morphList);
}
 
QUrl QQuick3DModel::source() const
{
    return m_source;
}
 
QQmlListProperty<QQuick3DMaterial> QQuick3DModel::materials()
{
    return QQmlListProperty<QQuick3DMaterial>(this,
                                            nullptr,
                                            QQuick3DModel::qmlAppendMaterial,
                                            QQuick3DModel::qmlMaterialsCount,
                                            QQuick3DModel::qmlMaterialAt,
                                            QQuick3DModel::qmlClearMaterials);
}
 
QQmlListProperty<QQuick3DMorphTarget> QQuick3DModel::morphTargets()
{
    return QQmlListProperty<QQuick3DMorphTarget>(this,
                                            nullptr,
                                            QQuick3DModel::qmlAppendMorphTarget,
                                            QQuick3DModel::qmlMorphTargetsCount,
                                            QQuick3DModel::qmlMorphTargetAt,
                                            QQuick3DModel::qmlClearMorphTargets);
}
 
QQuick3DInstancing *QQuick3DModel::instancing() const
{
    return m_instancing;
}
 
QQuick3DNode *QQuick3DModel::instanceRoot() const
{
    return m_instanceRoot;
}
 
// Source URL's need a bit of translation for the engine because of the
// use of fragment syntax for specifiying primitives and sub-meshes
// So we need to check for the fragment before translating to a qmlfile
 
QString QQuick3DModel::translateMeshSource(const QUrl &source, QObject *contextObject)
{
    QString fragment;
    if (source.hasFragment()) {
        // Check if this is an index, or primitive
        bool isNumber = false;
        source.fragment().toInt(&isNumber);
        fragment = QStringLiteral("#") + source.fragment();
        // If it wasn't an index, then it was a primitive
        if (!isNumber)
            return fragment;
    }
 
    const QQmlContext *context = qmlContext(contextObject);
    const auto resolvedUrl = context ? context->resolvedUrl(source) : source;
    const auto qmlSource = QQmlFile::urlToLocalFileOrQrc(resolvedUrl);
    return (qmlSource.isEmpty() ? source.path() : qmlSource) + fragment;
}
 
void QQuick3DModel::markAllDirty()
{
    m_dirtyAttributes = 0xffffffff;
    QQuick3DNode::markAllDirty();
}
 
bool QQuick3DModel::castsShadows() const
{
    return m_castsShadows;
}
 
bool QQuick3DModel::receivesShadows() const
{
    return m_receivesShadows;
}
 
bool QQuick3DModel::pickable() const
{
    return m_pickable;
}
 
QQuick3DGeometry *QQuick3DModel::geometry() const
{
    return m_geometry;
}
 
QQuick3DSkeleton *QQuick3DModel::skeleton() const
{
    return m_skeleton;
}
 
QQuick3DSkin *QQuick3DModel::skin() const
{
    return m_skin;
}
 
 
QList<QMatrix4x4> QQuick3DModel::inverseBindPoses() const
{
    return m_inverseBindPoses;
}
 
QQuick3DBounds3 QQuick3DModel::bounds() const
{
    return m_bounds;
}
 
float QQuick3DModel::depthBias() const
{
    return m_depthBias;
}
 
bool QQuick3DModel::receivesReflections() const
{
    return m_receivesReflections;
}
 
bool QQuick3DModel::castsReflections() const
{
    return m_castsReflections;
}
 
bool QQuick3DModel::isUsedInBakedLighting() const
{
    return m_usedInBakedLighting;
}
 
int QQuick3DModel::lightmapBaseResolution() const
{
    return m_lightmapBaseResolution;
}
 
QQuick3DBakedLightmap *QQuick3DModel::bakedLightmap() const
{
    return m_bakedLightmap;
}
 
float QQuick3DModel::instancingLodMin() const
{
    return m_instancingLodMin;
}
 
float QQuick3DModel::instancingLodMax() const
{
    return m_instancingLodMax;
}
 
void QQuick3DModel::setSource(const QUrl &source)
{
    if (m_source == source)
        return;
 
    m_source = source;
    emit sourceChanged();
    markDirty(SourceDirty);
    if (QQuick3DObjectPrivate::get(this)->sceneManager)
        QQuick3DObjectPrivate::get(this)->sceneManager->dirtyBoundingBoxList.append(this);
}
 
void QQuick3DModel::setCastsShadows(bool castsShadows)
{
    if (m_castsShadows == castsShadows)
        return;
 
    m_castsShadows = castsShadows;
    emit castsShadowsChanged();
    markDirty(ShadowsDirty);
}
 
void QQuick3DModel::setReceivesShadows(bool receivesShadows)
{
    if (m_receivesShadows == receivesShadows)
        return;
 
    m_receivesShadows = receivesShadows;
    emit receivesShadowsChanged();
    markDirty(ShadowsDirty);
}
 
void QQuick3DModel::setPickable(bool isPickable)
{
    if (m_pickable == isPickable)
        return;
 
    m_pickable = isPickable;
    emit pickableChanged();
    markDirty(PickingDirty);
}
 
void QQuick3DModel::setGeometry(QQuick3DGeometry *geometry)
{
    if (geometry == m_geometry)
        return;
 
    // Make sure to disconnect if the geometry gets deleted out from under us
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DModel::setGeometry, geometry, m_geometry);
 
    if (m_geometry)
        QObject::disconnect(m_geometryConnection);
    m_geometry = geometry;
 
    if (m_geometry) {
        m_geometryConnection
                = QObject::connect(m_geometry, &QQuick3DGeometry::geometryNodeDirty, [this]() {
            markDirty(GeometryDirty);
        });
    }
    emit geometryChanged();
    markDirty(GeometryDirty);
}
 
void QQuick3DModel::setSkeleton(QQuick3DSkeleton *skeleton)
{
    if (skeleton == m_skeleton)
        return;
 
    // Make sure to disconnect if the skeleton gets deleted out from under us
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DModel::setSkeleton, skeleton, m_skeleton);
 
    m_skeleton = skeleton;
 
    emit skeletonChanged();
    markDirty(SkeletonDirty);
}
 
void QQuick3DModel::setSkin(QQuick3DSkin *skin)
{
    if (skin == m_skin)
        return;
 
    // Make sure to disconnect if the skin gets deleted out from under us
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DModel::setSkin, skin, m_skin);
 
    m_skin = skin;
    emit skinChanged();
    markDirty(SkinDirty);
}
 
void QQuick3DModel::setInverseBindPoses(const QList<QMatrix4x4> &poses)
{
    if (m_inverseBindPoses == poses)
        return;
 
    m_inverseBindPoses = poses;
    emit inverseBindPosesChanged();
    markDirty(PoseDirty);
}
 
 
void QQuick3DModel::setBounds(const QVector3D &min, const QVector3D &max)
{
    if (!qFuzzyCompare(m_bounds.maximum(), max)
            || !qFuzzyCompare(m_bounds.minimum(), min))  {
        m_bounds.bounds = QSSGBounds3 { min, max };
        emit boundsChanged();
    }
}
 
void QQuick3DModel::setInstancing(QQuick3DInstancing *instancing)
{
    if (m_instancing == instancing)
        return;
 
    // Make sure to disconnect if the instance table gets deleted out from under us
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DModel::setInstancing, instancing, m_instancing);
    if (m_instancing)
        QObject::disconnect(m_instancingConnection);
    m_instancing = instancing;
    if (m_instancing) {
        m_instancingConnection = QObject::connect
                (m_instancing, &QQuick3DInstancing::instanceNodeDirty,
                 this, [this]{ markDirty(InstancesDirty);});
    }
    markDirty(InstancesDirty);
    emit instancingChanged();
}
 
void QQuick3DModel::setInstanceRoot(QQuick3DNode *instanceRoot)
{
    if (m_instanceRoot == instanceRoot)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DModel::setInstanceRoot, instanceRoot, m_instanceRoot);
 
    m_instanceRoot = instanceRoot;
    markDirty(InstanceRootDirty);
    emit instanceRootChanged();
}
 
void QQuick3DModel::setDepthBias(float bias)
{
    if (qFuzzyCompare(bias, m_depthBias))
        return;
 
    m_depthBias = bias;
    markDirty(PropertyDirty);
    emit depthBiasChanged();
}
 
void QQuick3DModel::setReceivesReflections(bool receivesReflections)
{
    if (m_receivesReflections == receivesReflections)
        return;
 
    m_receivesReflections = receivesReflections;
    emit receivesReflectionsChanged();
    markDirty(ReflectionDirty);
}
 
void QQuick3DModel::setCastsReflections(bool castsReflections)
{
    if (m_castsReflections == castsReflections)
        return;
    m_castsReflections = castsReflections;
    emit castsReflectionsChanged();
    markDirty(ReflectionDirty);
}
 
void QQuick3DModel::setUsedInBakedLighting(bool enable)
{
    if (m_usedInBakedLighting == enable)
        return;
 
    m_usedInBakedLighting = enable;
    emit usedInBakedLightingChanged();
    markDirty(PropertyDirty);
}
 
void QQuick3DModel::setLightmapBaseResolution(int resolution)
{
    resolution = qMax(128, resolution);
    if (m_lightmapBaseResolution == resolution)
        return;
 
    m_lightmapBaseResolution = resolution;
    emit lightmapBaseResolutionChanged();
    markDirty(PropertyDirty);
}
 
void QQuick3DModel::setBakedLightmap(QQuick3DBakedLightmap *bakedLightmap)
{
    if (m_bakedLightmap == bakedLightmap)
        return;
 
    if (m_bakedLightmap)
        m_bakedLightmap->disconnect(m_bakedLightmapSignalConnection);
 
    m_bakedLightmap = bakedLightmap;
 
    m_bakedLightmapSignalConnection = QObject::connect(m_bakedLightmap, &QQuick3DBakedLightmap::changed, this,
                                                       [this] { markDirty(PropertyDirty); });
 
    QObject::connect(m_bakedLightmap, &QObject::destroyed, this,
                     [this]
    {
        m_bakedLightmap = nullptr;
        markDirty(PropertyDirty);
    });
 
    emit bakedLightmapChanged();
    markDirty(PropertyDirty);
}
 
void QQuick3DModel::itemChange(ItemChange change, const ItemChangeData &value)
{
    if (change == QQuick3DObject::ItemSceneChange)
        updateSceneManager(value.sceneManager);
}
 
QSSGRenderGraphObject *QQuick3DModel::updateSpatialNode(QSSGRenderGraphObject *node)
{
    if (!node) {
        markAllDirty();
        node = new QSSGRenderModel();
    }
 
    QQuick3DNode::updateSpatialNode(node);
    int dirtyAttribute = 0;
 
    auto modelNode = static_cast<QSSGRenderModel *>(node);
    if (m_dirtyAttributes & SourceDirty)
        modelNode->meshPath = QSSGRenderPath(translateMeshSource(m_source, this));
    if (m_dirtyAttributes & PickingDirty)
        modelNode->setState(QSSGRenderModel::LocalState::Pickable, m_pickable);
 
    if (m_dirtyAttributes & ShadowsDirty) {
        modelNode->castsShadows = m_castsShadows;
        modelNode->receivesShadows = m_receivesShadows;
    }
 
    if (m_dirtyAttributes & MaterialsDirty) {
        if (!m_materials.isEmpty()) {
            if (modelNode->materials.isEmpty()) {
                // Easy mode, just add each material
                for (const Material &material : m_materials) {
                    QSSGRenderGraphObject *graphObject = QQuick3DObjectPrivate::get(material.material)->spatialNode;
                    if (graphObject)
                        modelNode->materials.append(graphObject);
                    else
                        dirtyAttribute |= MaterialsDirty; // We still got dirty materials
                }
            } else {
                // Hard mode, go through each material and see if they match
                if (modelNode->materials.size() != m_materials.size())
                    modelNode->materials.resize(m_materials.size());
                for (int i = 0; i < m_materials.size(); ++i) {
                    QSSGRenderGraphObject *graphObject = QQuick3DObjectPrivate::get(m_materials[i].material)->spatialNode;
                    if (modelNode->materials[i] != graphObject)
                        modelNode->materials[i] = graphObject;
                }
            }
        } else {
            // No materials
            modelNode->materials.clear();
        }
    }
 
    if (m_dirtyAttributes & MorphTargetsDirty) {
        if (!m_morphTargets.isEmpty()) {
            const int numMorphTarget = m_morphTargets.size();
            if (modelNode->morphTargets.isEmpty()) {
                // Easy mode, just add each morphTarget
                for (const auto morphTarget : std::as_const(m_morphTargets)) {
                    QSSGRenderGraphObject *graphObject = QQuick3DObjectPrivate::get(morphTarget)->spatialNode;
                    if (graphObject)
                        modelNode->morphTargets.append(graphObject);
                    else
                        dirtyAttribute |= MorphTargetsDirty; // We still got dirty morphTargets
                }
                modelNode->morphWeights.resize(numMorphTarget);
                modelNode->morphAttributes.resize(numMorphTarget);
            } else {
                // Hard mode, go through each morphTarget and see if they match
                if (modelNode->morphTargets.size() != numMorphTarget) {
                    modelNode->morphTargets.resize(numMorphTarget);
                    modelNode->morphWeights.resize(numMorphTarget);
                    modelNode->morphAttributes.resize(numMorphTarget);
                }
                for (int i = 0; i < numMorphTarget; ++i)
                    modelNode->morphTargets[i] = QQuick3DObjectPrivate::get(m_morphTargets.at(i))->spatialNode;
            }
        } else {
            // No morphTargets
            modelNode->morphTargets.clear();
        }
    }
 
    if (m_dirtyAttributes & quint32(InstancesDirty | InstanceRootDirty)) {
        // If we have an instance root set we have lower priority and the instance root node should already
        // have been created.
        QSSGRenderNode *instanceRootNode = nullptr;
        if (m_instanceRoot) {
            if (m_instanceRoot == this)
                instanceRootNode = modelNode;
            else
                instanceRootNode = static_cast<QSSGRenderNode *>(QQuick3DObjectPrivate::get(m_instanceRoot)->spatialNode);
        }
        if (instanceRootNode != modelNode->instanceRoot) {
            modelNode->instanceRoot = instanceRootNode;
            modelNode->markDirty(QSSGRenderNode::DirtyFlag::TransformDirty);
        }
 
        if (m_instancing) {
            modelNode->instanceTable = static_cast<QSSGRenderInstanceTable *>(QQuick3DObjectPrivate::get(m_instancing)->spatialNode);
        } else {
            modelNode->instanceTable = nullptr;
        }
    }
 
    if (m_dirtyAttributes & GeometryDirty) {
        if (m_geometry) {
            modelNode->geometry = static_cast<QSSGRenderGeometry *>(QQuick3DObjectPrivate::get(m_geometry)->spatialNode);
            setBounds(m_geometry->boundsMin(), m_geometry->boundsMax());
        } else {
            modelNode->geometry = nullptr;
            setBounds(QVector3D(), QVector3D());
        }
    }
 
    if (m_dirtyAttributes & SkeletonDirty) {
        if (m_skeleton) {
            modelNode->skeleton = static_cast<QSSGRenderSkeleton *>(QQuick3DObjectPrivate::get(m_skeleton)->spatialNode);
            if (modelNode->skeleton)
                modelNode->skeleton->skinningDirty = true;
        } else {
            modelNode->skeleton = nullptr;
        }
    }
 
    if (m_dirtyAttributes & SkinDirty) {
        if (m_skin)
            modelNode->skin = static_cast<QSSGRenderSkin *>(QQuick3DObjectPrivate::get(m_skin)->spatialNode);
        else
            modelNode->skin = nullptr;
    }
 
    if (m_dirtyAttributes & LodDirty) {
        modelNode->instancingLodMin = m_instancingLodMin;
        modelNode->instancingLodMax = m_instancingLodMax;
    }
 
    if (m_dirtyAttributes & PoseDirty) {
        modelNode->inverseBindPoses = m_inverseBindPoses.toVector();
        if (modelNode->skeleton)
            modelNode->skeleton->skinningDirty = true;
    }
 
    if (m_dirtyAttributes & PropertyDirty) {
        modelNode->m_depthBiasSq = QSSGRenderModel::signedSquared(m_depthBias);
        modelNode->usedInBakedLighting = m_usedInBakedLighting;
        modelNode->lightmapBaseResolution = uint(m_lightmapBaseResolution);
        if (m_bakedLightmap && m_bakedLightmap->isEnabled()) {
            modelNode->lightmapKey = m_bakedLightmap->key();
            const QString srcPrefix = m_bakedLightmap->loadPrefix();
            const QString srcPath = srcPrefix.isEmpty() ? QStringLiteral(".") : srcPrefix;
            const QQmlContext *context = qmlContext(m_bakedLightmap);
            const QUrl resolvedUrl = context ? context->resolvedUrl(srcPath) : srcPath;
            modelNode->lightmapLoadPath = QQmlFile::urlToLocalFileOrQrc(resolvedUrl);
        } else {
            modelNode->lightmapKey.clear();
            modelNode->lightmapLoadPath.clear();
        }
        modelNode->levelOfDetailBias = m_levelOfDetailBias;
    }
 
    if (m_dirtyAttributes & ReflectionDirty) {
        modelNode->receivesReflections = m_receivesReflections;
        modelNode->castsReflections = m_castsReflections;
    }
 
    m_dirtyAttributes = dirtyAttribute;
 
    return modelNode;
}
 
void QQuick3DModel::markDirty(QQuick3DModel::QSSGModelDirtyType type)
{
    if (InstanceRootDirty & quint32(type))
        QQuick3DObjectPrivate::get(this)->dirty(QQuick3DObjectPrivate::InstanceRootChanged);
 
    if (!(m_dirtyAttributes & quint32(type))) {
        m_dirtyAttributes |= quint32(type);
        update();
    }
}
 
void QQuick3DModel::updateSceneManager(QQuick3DSceneManager *sceneManager)
{
    if (sceneManager) {
        sceneManager->dirtyBoundingBoxList.append(this);
        QQuick3DObjectPrivate::refSceneManager(m_skeleton, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_skin, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_geometry, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_instancing, *sceneManager);
        for (Material &mat : m_materials) {
            if (!mat.material->parentItem() && !QQuick3DObjectPrivate::get(mat.material)->sceneManager) {
                if (!mat.refed) {
                    QQuick3DObjectPrivate::refSceneManager(mat.material, *sceneManager);
                    mat.refed = true;
                }
            }
        }
    } else {
        QQuick3DObjectPrivate::derefSceneManager(m_skeleton);
        QQuick3DObjectPrivate::derefSceneManager(m_skin);
        QQuick3DObjectPrivate::derefSceneManager(m_geometry);
        QQuick3DObjectPrivate::derefSceneManager(m_instancing);
        for (Material &mat : m_materials) {
            if (mat.refed) {
                QQuick3DObjectPrivate::derefSceneManager(mat.material);
                mat.refed = false;
            }
        }
    }
}
 
void QQuick3DModel::onMaterialDestroyed(QObject *object)
{
    bool found = false;
    for (int i = 0; i < m_materials.size(); ++i) {
        if (m_materials[i].material == object) {
            m_materials.removeAt(i--);
            found = true;
        }
    }
    if (found)
        markDirty(QQuick3DModel::MaterialsDirty);
}
 
void QQuick3DModel::qmlAppendMaterial(QQmlListProperty<QQuick3DMaterial> *list, QQuick3DMaterial *material)
{
    if (material == nullptr)
        return;
    QQuick3DModel *self = static_cast<QQuick3DModel *>(list->object);
    self->m_materials.push_back({ material, false });
    self->markDirty(QQuick3DModel::MaterialsDirty);
 
    if (material->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 *>(material->parent());
        if (parentItem) {
            material->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(material)->refSceneManager(*sceneManager);
                // Have to keep track if we called refSceneManager because we
                // can end up in double deref attempts when a model is going
                // away, due to updateSceneManager() being called on
                // ItemSceneChanged (and also doing deref). We must ensure that
                // is one deref for each ref.
                self->m_materials.last().refed = true;
            }
            // else: If there's no scene manager, defer until one is set, see itemChange()
        }
    }
 
    // Make sure materials are removed when destroyed
    connect(material, &QQuick3DMaterial::destroyed, self, &QQuick3DModel::onMaterialDestroyed);
}
 
QQuick3DMaterial *QQuick3DModel::qmlMaterialAt(QQmlListProperty<QQuick3DMaterial> *list, qsizetype index)
{
    QQuick3DModel *self = static_cast<QQuick3DModel *>(list->object);
    return self->m_materials.at(index).material;
}
 
qsizetype QQuick3DModel::qmlMaterialsCount(QQmlListProperty<QQuick3DMaterial> *list)
{
    QQuick3DModel *self = static_cast<QQuick3DModel *>(list->object);
    return self->m_materials.size();
}
 
void QQuick3DModel::qmlClearMaterials(QQmlListProperty<QQuick3DMaterial> *list)
{
    QQuick3DModel *self = static_cast<QQuick3DModel *>(list->object);
    for (Material &mat : self->m_materials) {
        if (mat.material->parentItem() == nullptr) {
            if (mat.refed) {
                QQuick3DObjectPrivate::get(mat.material)->derefSceneManager();
                mat.refed = false;
            }
        }
        mat.material->disconnect(self, SLOT(onMaterialDestroyed(QObject*)));
    }
    self->m_materials.clear();
    self->markDirty(QQuick3DModel::MaterialsDirty);
}
 
void QQuick3DModel::onMorphTargetDestroyed(QObject *object)
{
    bool found = false;
    for (int i = 0; i < m_morphTargets.size(); ++i) {
        if (m_morphTargets.at(i) == object) {
            m_morphTargets.removeAt(i--);
            found = true;
        }
    }
    if (found) {
        markDirty(QQuick3DModel::MorphTargetsDirty);
        m_numMorphAttribs = 0;
    }
}
 
void QQuick3DModel::qmlAppendMorphTarget(QQmlListProperty<QQuick3DMorphTarget> *list, QQuick3DMorphTarget *morphTarget)
{
    if (morphTarget == nullptr)
        return;
    QQuick3DModel *self = static_cast<QQuick3DModel *>(list->object);
    if (self->m_numMorphAttribs >= 8) {
        qWarning("The number of morph attributes exceeds 8. This morph target will be ignored.");
        return;
    }
    self->m_morphTargets.push_back(morphTarget);
    self->m_numMorphAttribs += morphTarget->numAttribs();
    if (self->m_numMorphAttribs > 8)
        qWarning("The number of morph attributes exceeds 8. This morph target will be supported partially.");
 
    self->markDirty(QQuick3DModel::MorphTargetsDirty);
 
    if (morphTarget->parentItem() == nullptr) {
        // If the morphTarget has no parent, check if it has a hierarchical parent that's a QQuick3DObject
        // and re-parent it to that, e.g., inline morphTargets
        QQuick3DObject *parentItem = qobject_cast<QQuick3DObject *>(morphTarget->parent());
        if (parentItem) {
            morphTarget->setParentItem(parentItem);
        } else { // If no valid parent was found, make sure the morphTarget refs our scene manager
            const auto &scenManager = QQuick3DObjectPrivate::get(self)->sceneManager;
            if (scenManager)
                QQuick3DObjectPrivate::get(morphTarget)->refSceneManager(*scenManager);
            // else: If there's no scene manager, defer until one is set, see itemChange()
        }
    }
 
    // Make sure morphTargets are removed when destroyed
    connect(morphTarget, &QQuick3DMorphTarget::destroyed, self, &QQuick3DModel::onMorphTargetDestroyed);
}
 
QQuick3DMorphTarget *QQuick3DModel::qmlMorphTargetAt(QQmlListProperty<QQuick3DMorphTarget> *list, qsizetype index)
{
    QQuick3DModel *self = static_cast<QQuick3DModel *>(list->object);
    if (index >= self->m_morphTargets.size()) {
        qWarning("The index exceeds the range of valid morph targets.");
        return nullptr;
    }
    return self->m_morphTargets.at(index);
}
 
qsizetype QQuick3DModel::qmlMorphTargetsCount(QQmlListProperty<QQuick3DMorphTarget> *list)
{
    QQuick3DModel *self = static_cast<QQuick3DModel *>(list->object);
    return self->m_morphTargets.size();
}
 
void QQuick3DModel::qmlClearMorphTargets(QQmlListProperty<QQuick3DMorphTarget> *list)
{
    QQuick3DModel *self = static_cast<QQuick3DModel *>(list->object);
    for (const auto &morph : std::as_const(self->m_morphTargets)) {
        if (morph->parentItem() == nullptr)
            QQuick3DObjectPrivate::get(morph)->derefSceneManager();
        morph->disconnect(self, SLOT(onMorphTargetDestroyed(QObject*)));
    }
    self->m_morphTargets.clear();
    self->m_numMorphAttribs = 0;
    self->markDirty(QQuick3DModel::MorphTargetsDirty);
}
 
void QQuick3DModel::setInstancingLodMin(float minDistance)
{
    if (qFuzzyCompare(m_instancingLodMin, minDistance))
        return;
    m_instancingLodMin = minDistance;
    emit instancingLodMinChanged();
    markDirty(LodDirty);
}
 
void QQuick3DModel::setInstancingLodMax(float maxDistance)
{
    if (qFuzzyCompare(m_instancingLodMax, maxDistance))
        return;
    m_instancingLodMax = maxDistance;
    emit instancingLodMaxChanged();
    markDirty(LodDirty);
}
 
float QQuick3DModel::levelOfDetailBias() const
{
    return m_levelOfDetailBias;
}
 
void QQuick3DModel::setLevelOfDetailBias(float newLevelOfDetailBias)
{
    if (qFuzzyCompare(m_levelOfDetailBias, newLevelOfDetailBias))
        return;
    m_levelOfDetailBias = newLevelOfDetailBias;
    emit levelOfDetailBiasChanged();
    markDirty(QQuick3DModel::PropertyDirty);
}
 
QT_END_NAMESPACE