Revision control
Copy as Markdown
// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#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
/*!
\qmltype Model
\inherits Node
\inqmlmodule QtQuick3D
\brief Lets you load a 3D model data.
The Model item makes it possible to load a mesh and modify how its shaded, by adding materials
to it. For a model to be renderable, it needs at least a mesh and a material.
\section1 Mesh format and built-in primitives
The model can load static meshes from storage or one of the built-in primitive types.
The mesh format used is a run-time format that's native to the engine, but additional formats are
supported through the asset import tool \l {Balsam Asset Import Tool}{Balsam}.
The built-in primitives can be loaded by setting the \c source property to one of these values:
\c {#Rectangle, #Sphere, #Cube, #Cylinder or #Cone}.
\qml
Model {
source: "#Sphere"
}
\endqml
The table below describes the built-in meshes in more detail.
\table
\header
\li Name
\li Description
\li No. faces
\row
\li #Cone
\li A cone with a height and diameter of \c{100}. The base is at the
origin and the cone is pointing upwards in the y direction.
\li \c{78}
\row
\li #Cube
\li A cube centered at the origin with \c{100} long sides along x, y and z.
\li \c{12}
\row
\li #Cylinder
\li A cylinder with \c{100} height and diameter centered at the origin
expanding along the y direction.
\li \c{316}
\row
\li #Rectangle
\li A rectangle with \c{100} width and height centered at the origin
lying in the xy plane.
\li \c{2}
\row
\li #Sphere
\li A sphere with \c{100} diameter centered at the origin.
\li \c{4900}
\endtable
\section2 Custom geometry
In addition to using static meshes, you can implement a
\l {QQuick3DGeometry}{custom geometry} provider that provides the model with
custom vertex data at run-time. See the
\l {Qt Quick 3D - Custom Geometry Example}{Custom Geometry Example} for an
example on how to create and use a custom material with your model.
\section1 Materials
A model can consist of several sub-meshes, each of which can have its own
material. The sub-mesh uses a material from the \l{materials} list,
corresponding to its index. If the number of materials is less than the
sub-meshes, the last material in the list is used for subsequent sub-meshes.
This is demonstrated in the
\l {Qt Quick 3D - Sub-mesh Example}{Sub-mesh example}.
You can use the following materials with the model item:
\l {PrincipledMaterial}, \l {DefaultMaterial}, and \l {CustomMaterial}.
\section1 Picking
\e Picking is the process of sending a ray through the scene from some
starting position to find which models intersect with the ray. In
Qt Quick 3D, the ray is normally sent from the view using 2D coordinates
resulting from a touch or mouse event. If a model was hit by the ray,
\l {pickResult} will be returned with a handle to the model and information
about where the ray hit the model. For models that use
\l {QQuick3DGeometry}{custom geometry}, the picking is less accurate than
for static mesh data, as picking is only done against the model's
\l {bounds}{bounding volume}. If the ray goes through more than one model,
the closest \l {Model::pickable}{pickable} model is selected.
Note that for models to be \l {Model::pickable}{pickable}, their
\l {Model::pickable}{pickable} property must be set to \c true. For more
information, see \l {Qt Quick 3D - Picking example}.
*/
/*!
\qmlvaluetype bounds
\inqmlmodule QtQuick3D
\since 5.15
\brief Specifies the bounds of a model.
bounds specify a bounding box with minimum and maximum points.
bounds is a readonly property of the model.
*/
/*!
\qmlproperty vector3d bounds::minimum
Specifies the minimum point of the model bounds.
\sa maximum
*/
/*!
\qmlproperty vector3d bounds::maximum
Specifies the maximum point of the model bounds.
\sa minimum
*/
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);
}
/*!
\qmlproperty url Model::source
This property defines the location of the mesh file containing the geometry
of this Model or one of the built-in primitive meshes listed below
as described in \l {Mesh format and built-in primitives}.
\list
\li "#Rectangle"
\li "#Sphere"
\li "#Cube"
\li "#Cone"
\li "#Cylinder"
\endlist
*/
QUrl QQuick3DModel::source() const
{
return m_source;
}
/*!
\qmlproperty List<QtQuick3D::Material> Model::materials
This property contains a list of materials used to render the provided
geometry. To render anything, there must be at least one material. Normally
there should be one material for each sub-mesh included in the source
geometry.
\sa {Qt Quick 3D - Sub-mesh Example}
*/
QQmlListProperty<QQuick3DMaterial> QQuick3DModel::materials()
{
return QQmlListProperty<QQuick3DMaterial>(this,
nullptr,
QQuick3DModel::qmlAppendMaterial,
QQuick3DModel::qmlMaterialsCount,
QQuick3DModel::qmlMaterialAt,
QQuick3DModel::qmlClearMaterials);
}
/*!
\qmlproperty List<QtQuick3D::MorphTarget> Model::morphTargets
This property contains a list of \l [QtQuick3D QML] {MorphTarget}{MorphTarget}s used to
render the provided geometry. Meshes should have at least one attribute
among positions, normals, tangents, binormals, texture coordinates,
and vertex colors for the morph targets.
\sa {MorphTarget}
*/
QQmlListProperty<QQuick3DMorphTarget> QQuick3DModel::morphTargets()
{
return QQmlListProperty<QQuick3DMorphTarget>(this,
nullptr,
QQuick3DModel::qmlAppendMorphTarget,
QQuick3DModel::qmlMorphTargetsCount,
QQuick3DModel::qmlMorphTargetAt,
QQuick3DModel::qmlClearMorphTargets);
}
/*!
\qmlproperty QtQuick3D::Instancing Model::instancing
If this property is set, the model will not be rendered normally. Instead, a number of
instances of the model will be rendered, as defined by the instance table.
\sa Instancing
*/
QQuick3DInstancing *QQuick3DModel::instancing() const
{
return m_instancing;
}
/*!
\qmlproperty QtQuick3D::Node Model::instanceRoot
This property defines the origin of the instance’s coordinate system.
See the \l{Transforms and instancing}{overview documentation} for a detailed explanation.
\sa instancing, 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();
}
/*!
\qmlproperty bool Model::castsShadows
When this property is \c true, the geometry of this model is used when
rendering to the shadow maps, and is also generating shadows in baked
lighting.
The default value is \c true.
*/
bool QQuick3DModel::castsShadows() const
{
return m_castsShadows;
}
/*!
\qmlproperty bool Model::receivesShadows
When this property is set to \c true, the model's materials take shadow
contribution from shadow casting lights into account.
\note When lightmapping is enabled for this model, fully baked lights with
Light::bakeMode set to Light.BakeModeAll will always generate (baked)
shadows on the model, regardless of the value of this property.
The default value is \c true.
*/
bool QQuick3DModel::receivesShadows() const
{
return m_receivesShadows;
}
/*!
\qmlproperty bool Model::pickable
This property controls whether the model is pickable or not. Set this property
to \c true to make the model pickable. Models are not pickable by default.
\sa {View3D::pick}
*/
bool QQuick3DModel::pickable() const
{
return m_pickable;
}
/*!
\qmlproperty Geometry Model::geometry
Specify a custom geometry for the model. The Model::source must be empty when custom geometry
is used.
*/
QQuick3DGeometry *QQuick3DModel::geometry() const
{
return m_geometry;
}
/*!
\qmlproperty Skeleton Model::skeleton
Contains the skeleton for the model. The Skeleton is used together with \l {inverseBindPoses}
for \l {Vertex Skinning}{skinning}.
\note Meshes of the model must have both joints and weights attributes.
\note If this property is set, skinning animation is enabled. It means
that \l {Model} is transformed based on \l {Skeleton} ignoring Model's global
transformation.
\sa {Model::inverseBindPoses}, {Qt Quick 3D - Simple Skinning Example}
*/
QQuick3DSkeleton *QQuick3DModel::skeleton() const
{
return m_skeleton;
}
/*!
\qmlproperty Skin Model::skin
Contains the skeleton for the model. The Skeleton is used for
\l {Vertex Skinning}{skinning}.
\note Meshes of the model must have both joints and weights attributes.
\note If this property is set, skinning animation is enabled. This means
the \l {Model} will be transformed based on \l {Skin::joints} and the
Model's global transformation will be ignored.
\note If a model has both a skeleton and a skin, then the skin will be used.
\sa {Model::skeleton} {Qt Quick 3D - Simple Skinning Example}
*/
QQuick3DSkin *QQuick3DModel::skin() const
{
return m_skin;
}
/*!
\qmlproperty List<matrix4x4> Model::inverseBindPoses
This property contains a list of Inverse Bind Pose matrixes used for the
skeletal animation. Each inverseBindPose matrix means the inverse of the
global transform of the repective \l {Joint::index} in \l {skeleton}, which
will be used initially.
\note This property is only used if the Model::skeleton is valid.
\note If some of the matrices are not set, identity values will be used.
\sa {skeleton} {Joint::index}
*/
QList<QMatrix4x4> QQuick3DModel::inverseBindPoses() const
{
return m_inverseBindPoses;
}
/*!
\qmlproperty Bounds Model::bounds
The bounds of the model descibes the extents of the bounding volume around the model.
\note The bounds might not be immediately available if the model needs to be loaded first.
\readonly
*/
QQuick3DBounds3 QQuick3DModel::bounds() const
{
return m_bounds;
}
/*!
\qmlproperty real Model::depthBias
Holds the depth bias of the model. Depth bias is added to the object distance from camera when sorting
objects. This can be used to force rendering order between objects close to each other, that
might otherwise be rendered in different order in different frames. Negative values cause the
sorting value to move closer to the camera while positive values move it further from the camera.
*/
float QQuick3DModel::depthBias() const
{
return m_depthBias;
}
/*!
\qmlproperty bool Model::receivesReflections
When this property is set to \c true, the model's materials take reflections contribution from
a reflection probe. If the model is inside more than one reflection probe at the same time,
the nearest reflection probe is taken into account.
*/
bool QQuick3DModel::receivesReflections() const
{
return m_receivesReflections;
}
/*!
\qmlproperty bool Model::castsReflections
\since 6.4
When this property is set to \c true, the model is rendered by reflection probes and can be
seen in the reflections.
*/
bool QQuick3DModel::castsReflections() const
{
return m_castsReflections;
}
/*!
\qmlproperty bool Model::usedInBakedLighting
When this property is set to \c true, the model contributes to baked
lighting, such as lightmaps, for example in form of casting shadows or
indirect light. This setting is independent of controlling lightmap
generation for the model, use \l bakedLightmap for that.
The default value is \c false.
\note The default value is false, because designers and developers must
always evaluate on a per-model basis if the object is suitable to take part
in baked lighting.
\warning Models with dynamically changing properties, for example, animated
position, rotation, or other properties, are not suitable for participating
in baked lighting.
For more information on how to bake lightmaps, see the \l Lightmapper
documentation.
This property is relevant only when baking lightmaps. It has no effect
afterwards, when using the generated lightmaps during rendering.
\sa Light::bakeMode, bakedLightmap, Lightmapper, {Lightmaps and Global Illumination}
*/
bool QQuick3DModel::isUsedInBakedLighting() const
{
return m_usedInBakedLighting;
}
/*!
\qmlproperty int Model::lightmapBaseResolution
\deprecated [6.10] This has no effect. Use Model::texelsPerUnit instead.
*/
int QQuick3DModel::lightmapBaseResolution() const
{
return m_lightmapBaseResolution;
}
/*!
\qmlproperty BakedLightmap Model::bakedLightmap
When this property is set to a valid, enabled BakedLightmap object, the
model will get a lightmap generated when baking lighting, the lightmap is
then stored persistently. When rendering, the model will load and use the
associated lightmap. The default value is null.
\note When the intention is to generate a persistently stored lightmap for
a Model, both bakedLightmap and \l usedInBakedLighting must be set on it,
in order to indicate that the Model not only participates in the
lightmapped scene, but also wants a full lightmap to be baked and stored.
For more information on how to bake lightmaps, see the \l Lightmapper
documentation.
This property is relevant both when baking and when using lightmaps. A
consistent state between the baking run and the subsequent runs that use
the generated data is essential. For example, changing the lightmap key
will make it impossible to load the previously generated data. An exception
is \l {BakedLightmap::}{enabled}, which can be used to dynamically toggle
the usage of lightmaps (outside of the baking run), but be aware that the
rendered results will depend on the Lights' \l{Light::bakeMode}{bakeMode}
settings in the scene.
\sa usedInBakedLighting, Lightmapper
*/
QQuick3DBakedLightmap *QQuick3DModel::bakedLightmap() const
{
return m_bakedLightmap;
}
/*!
\qmlproperty real Model::instancingLodMin
Defines the minimum distance from camera that an instance of this model is shown.
Used for a level of detail implementation.
*/
float QQuick3DModel::instancingLodMin() const
{
return m_instancingLodMin;
}
/*!
\qmlproperty real Model::instancingLodMax
Defines the maximum distance from camera that an instance of this model is shown.
Used for a level of detail implementation.
*/
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, [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;
qWarning() << "Model::lightmapBaseResolution is deprecated and will have no effect.";
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) {
const QString path = translateMeshSource(m_source, this);
const QString lightmapKey = m_bakedLightmap ? m_bakedLightmap->key() : QString();
modelNode->meshPath = QSSGRenderPath(path, lightmapKey);
}
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 : std::as_const(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->texelsPerUnit = m_texelsPerUnit;
if (m_bakedLightmap && m_bakedLightmap->isEnabled()) {
modelNode->lightmapKey = m_bakedLightmap->key();
} else {
modelNode->lightmapKey.clear();
}
// Need new hash if lightmapKey has changed
const QString path = translateMeshSource(m_source, this);
modelNode->meshPath = QSSGRenderPath(path, modelNode->lightmapKey);
modelNode->levelOfDetailBias = m_levelOfDetailBias;
modelNode->instancingLodFactor = m_instancingLodFactor;
modelNode->motionVectorEnabled = m_motionVectorEnabled;
modelNode->motionVectorScale = m_motionVectorScale;
}
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;
}
}
disconnect(mat.material, &QQuick3DMaterial::destroyed, self, &QQuick3DModel::onMaterialDestroyed);
}
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);
}
}
void QQuick3DModel::qmlAppendMorphTarget(QQmlListProperty<QQuick3DMorphTarget> *list, QQuick3DMorphTarget *morphTarget)
{
if (morphTarget == nullptr)
return;
QQuick3DModel *self = static_cast<QQuick3DModel *>(list->object);
self->m_morphTargets.push_back(morphTarget);
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();
disconnect(morph, &QQuick3DMorphTarget::destroyed, self, &QQuick3DModel::onMorphTargetDestroyed);
}
self->m_morphTargets.clear();
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);
}
/*!
\qmlproperty real Model::instancingLodFactor
\since 6.12
\default 0.0
This property allows manual determination of the level of detail (LOD) for
specific levels of instanced models.
In situations where a scene contains multiple LOD levels for large instance
tables, it is necessary to manually select the most appropriate detail level.
This is required because automatic LOD management cannot correctly calculate
the detail for individual instances, as their transformation data only becomes
available during the GPU rendering stage.
To reduce geometry overhead at specific LOD levels, you can manually specify
\c instancingLodFactor. The closer the value is to \c 1.0, the less geometry
will be rendered for the object. A value of \c 0.0 means the entire geometry
will be offloaded/rendered at full detail.
\note This property is specifically used to override automatic LOD calculation
when the proximity of individual instances to the camera is not predetermined.
\sa levelOfDetailBias
*/
float QQuick3DModel::instancingLodFactor() const
{
return m_instancingLodFactor;
}
void QQuick3DModel::setInstancingLodFactor(float newInstancingLodFactor)
{
if (qFuzzyCompare(m_instancingLodFactor, newInstancingLodFactor))
return;
m_instancingLodFactor = newInstancingLodFactor;
emit instancingLodFactorChanged();
markDirty(QQuick3DModel::PropertyDirty);
}
/*!
\qmlproperty real Model::levelOfDetailBias
\since 6.5
This property changes the size the model needs to be when rendered before the
automatic level of detail meshes are used. Each generated level of detail
mesh contains an ideal size value that each level should be shown, which is
a ratio of how much of the rendered scene will be that mesh. A model that
represents only a few pixels on screen will not require the full geometry
to look correct, so a lower level of detail mesh will be used instead in
this case. This value is a bias to the ideal value such that a value smaller
than \c 1.0 will require an even smaller rendered size before switching to
a lesser level of detail. Values above \c 1.0 will lead to lower levels of detail
being used sooner. A value of \c 0.0 will disable the usage of levels of detail
completely.
The default value is \c 1.0
\note This property will only have an effect when the Model's geometry contains
levels of detail.
\sa Camera::levelOfDetailBias
*/
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);
}
/*!
\qmlproperty real Model::texelsPerUnit
\since 6.10
\default 0.0
A value greater than zero means this value will override the
\l {Lightmapper::texelsPerUnit} value for this specific model during
lightmap baking.
\sa Lightmapper::texelsPerUnit
*/
float QQuick3DModel::texelsPerUnit() const
{
return m_texelsPerUnit;
}
void QQuick3DModel::setTexelsPerUnit(float newTexelsPerUnit)
{
if (qFuzzyCompare(m_texelsPerUnit, newTexelsPerUnit))
return;
m_texelsPerUnit = newTexelsPerUnit;
emit texelsPerUnitChanged();
markDirty(PropertyDirty);
}
/*!
\qmlproperty bool Model::motionVectorEnabled
\since 6.11
\default true
Specifies whether the model participates in the motion vector pass.
When this property is set to \c true, the model contributes its
motion information to the motion vector buffer. This is used by
temporal anti-aliasing (TAA) and other effects that rely on
per-pixel motion data.
When set to \c false, the model is excluded from motion vector
generation.
\sa Model::motionVectorScale
*/
bool QQuick3DModel::motionVectorEnabled() const
{
return m_motionVectorEnabled;
}
void QQuick3DModel::setMotionVectorEnabled(bool newMotionVectorEnabled)
{
if (m_motionVectorEnabled == newMotionVectorEnabled)
return;
m_motionVectorEnabled = newMotionVectorEnabled;
emit motionVectorEnabledChanged();
markDirty(QQuick3DModel::PropertyDirty);
}
/*!
\qmlproperty real Model::motionVectorScale
\since 6.11
\default 1.0
Specifies a scaling factor applied to the model's generated motion
vectors.
A value of \c 1.0 preserves the model's actual motion, while values
greater than \c 1.0 exaggerate the motion vectors and values lower
than \c 1.0 reduce them. This can be useful for stylized effects or
fine-tuning visual behavior in effects that rely on the motion
vector buffer.
\sa Model::motionVectorEnabled
*/
float QQuick3DModel::motionVectorScale() const
{
return m_motionVectorScale;
}
void QQuick3DModel::setMotionVectorScale(float newMotionVectorScale)
{
if (qFuzzyCompare(m_motionVectorScale, newMotionVectorScale))
return;
m_motionVectorScale = newMotionVectorScale;
emit motionVectorScaleChanged();
markDirty(QQuick3DModel::PropertyDirty);
}
QT_END_NAMESPACE