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 "qquick3dparticlemodelparticle_p.h"
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \qmltype ModelParticle3D
++ \inherits Particle3D
++ \inqmlmodule QtQuick3D.Particles3D
++ \brief Particle using a Qt Quick 3D Model.
++ \since 6.2
++
++ The ModelParticle3D is a logical particle element that creates particles
++ from a Qt Quick 3D \l Model component.
++ */
++
++ QQuick3DParticleModelParticle::QQuick3DParticleModelParticle(QQuick3DNode *parent)
++ : QQuick3DParticle(parent)
++ , m_initialScale(1.0f, 1.0f, 1.0f)
++ {
++ QObject::connect(this, &QQuick3DParticle::maxAmountChanged, this, [this]() {
++ handleMaxAmountChanged(m_maxAmount);
++ });
++ QObject::connect(this, &QQuick3DParticle::sortModeChanged, this, [this]() {
++ handleSortModeChanged(sortMode());
++ });
++ }
++
++ void QQuick3DParticleModelParticle::handleMaxAmountChanged(int amount)
++ {
++ if (m_particleData.size() == amount)
++ return;
++
++ m_particleData.resize(amount);
++ m_particleData.fill({});
++ }
++
++ /*!
++ \qmlproperty Component ModelParticle3D::delegate
++
++ The delegate provides a template defining each object instantiated by the particle.
++
++ For example, to allocate 200 red cube particles:
++
++ \qml
++ Component {
++ id: particleComponent
++ Model {
++ source: "#Cube"
++ scale: Qt.vector3d(0.2, 0.2, 0.2)
++ materials: DefaultMaterial { }
++ }
++ }
++
++ ModelParticle3D {
++ id: particleRed
++ delegate: particleComponent
++ maxAmount: 200
++ color: "#ff0000"
++ }
++ \endqml
++
++ \note The content instantiated from the delegate keeps its own
++ \l {QtQuick3D::Node::layers}{layers} assignment; the layers value of the
++ \l ParticleSystem3D is not applied to it. To render the particles on a
++ specific content layer, set the layers property on the nodes in the
++ delegate.
++ */
++ QQmlComponent *QQuick3DParticleModelParticle::delegate() const
++ {
++ return m_delegate.data();
++ }
++
++ void QQuick3DParticleModelParticle::setDelegate(QQmlComponent *delegate)
++ {
++ if (delegate == m_delegate)
++ return;
++ m_delegate = delegate;
++
++ regenerate();
++ Q_EMIT delegateChanged();
++ }
++
++ class QQuick3DParticleInstanceTable : public QQuick3DInstancing
++ {
++ struct SortData
++ {
++ float age;
++ int index;
++ };
++
++ public:
++ QQuick3DParticleInstanceTable() {}
++ void clear() { m_instances.clear(); m_sortData.clear(); }
++ void commit() { sort(); markDirty(); }
++ void addInstance(const QVector3D &position,
++ const QVector3D &scale,
++ const QVector3D &eulerRotation,
++ const QColor &color,
++ float age) {
++ auto entry = calculateTableEntry(position, scale, eulerRotation, color);
++ m_instances.append(reinterpret_cast<char *>(&entry), sizeof(InstanceTableEntry));
++ if (m_ageSorting)
++ m_sortData.append({age, int(m_instances.size() / sizeof(InstanceTableEntry))});
++ }
++ void setSorting(bool enable, bool inverted = false)
++ {
++ m_ageSorting = enable;
++ m_inverted = inverted;
++ }
++ protected:
++ QByteArray getInstanceBuffer(int *instanceCount) override
++ {
++ if (instanceCount)
++ *instanceCount = int(m_instances.size() / sizeof(InstanceTableEntry));
++
++ if (!m_ageSorting)
++ return m_instances;
++ return m_sortedInstances;
++ }
++ void sort()
++ {
++ if (!m_ageSorting)
++ return;
++
++ if (m_inverted) {
++ std::sort(m_sortData.begin(), m_sortData.end(), [&](const SortData &a, const SortData &b) {
++ return a.age < b.age;
++ });
++ } else {
++ std::sort(m_sortData.begin(), m_sortData.end(), [&](const SortData &a, const SortData &b) {
++ return a.age > b.age;
++ });
++ }
++ m_sortedInstances.resize(m_instances.size());
++ const InstanceTableEntry *src = reinterpret_cast<InstanceTableEntry *>(m_instances.data());
++ InstanceTableEntry *dst = reinterpret_cast<InstanceTableEntry *>(m_sortedInstances.data());
++ for (auto &e : m_sortData)
++ *dst++ = src[e.index];
++ }
++
++ private:
++ QList<SortData> m_sortData;
++ QByteArray m_instances;
++ QByteArray m_sortedInstances;
++ bool m_ageSorting = false;
++ bool m_inverted = false;
++ };
++
++ void QQuick3DParticleModelParticle::handleSortModeChanged(QQuick3DParticle::SortMode mode)
++ {
++ if (m_instanceTable) {
++ if (mode == QQuick3DParticle::SortNewest || mode == QQuick3DParticle::SortOldest)
++ m_instanceTable->setSorting(true, mode == QQuick3DParticle::SortNewest);
++ else
++ m_instanceTable->setSorting(false);
++ m_instanceTable->setDepthSortingEnabled(mode == QQuick3DParticle::SortDistance);
++ }
++ }
++
++ /*!
++ \qmlproperty Instancing ModelParticle3D::instanceTable
++
++ The instanceTable provides access to the \l Instancing table of the model particle.
++ ModelParticle3D uses an internal instance table to implement efficient rendering.
++ This table can be applied to the \l{Model::instancing}{instancing} property of models
++ that are not part of the particle system.
++
++ It is also possible to use this feature to provide an instancing table without showing any
++ particles. This is done by omitting the \l delegate property. For example:
++
++ \qml
++ ParticleSystem3D {
++ id: psystem
++ ModelParticle3D {
++ id: particleRed
++ maxAmount: 200
++ color: "#ff0000"
++ colorVariation: Qt.vector4d(0.5,0.5,0.5,0.5)
++ }
++
++ ParticleEmitter3D {
++ particle: particleRed
++ velocity: VectorDirection3D {
++ direction: Qt.vector3d(-20, 200, 0)
++ directionVariation: Qt.vector3d(20, 20, 20)
++ }
++ particleScale: 0.2
++ emitRate: 20
++ lifeSpan: 2000
++ }
++ }
++
++ Model {
++ source: "#Sphere"
++ instancing: particleRed.instanceTable
++ materials: PrincipledMaterial {
++ baseColor: "yellow"
++ }
++ }
++ \endqml
++ */
++
++ QQuick3DInstancing *QQuick3DParticleModelParticle::instanceTable() const
++ {
++ return m_instanceTable;
++ }
++
++ void QQuick3DParticleModelParticle::clearInstanceTable()
++ {
++ if (m_instanceTable)
++ m_instanceTable->clear();
++ }
++
++ void QQuick3DParticleModelParticle::addInstance(const QVector3D &position, const QVector3D &scale, const QVector3D &eulerRotation, const QColor &color, float age)
++ {
++ if (m_instanceTable)
++ m_instanceTable->addInstance(position, scale, eulerRotation, color, age);
++ }
++
++ void QQuick3DParticleModelParticle::commitInstance()
++ {
++ if (m_instanceTable) {
++ m_instanceTable->setHasTransparency(hasTransparency());
++ m_instanceTable->commit();
++ }
++ }
++
++ static void setInstancing(QQuick3DNode *node, QQuick3DInstancing *instanceTable, float bias)
++ {
++ auto *asModel = qobject_cast<QQuick3DModel *>(node);
++ if (asModel) {
++ asModel->setInstancing(instanceTable);
++ asModel->setDepthBias(bias);
++ }
++ const auto children = node->childItems();
++ for (auto *child : children) {
++ auto *childNode = qobject_cast<QQuick3DNode *>(child);
++ if (childNode)
++ setInstancing(childNode, instanceTable, bias);
++ }
++ }
++
++ void QQuick3DParticleModelParticle::updateDepthBias(float bias)
++ {
++ setInstancing(m_node, m_instanceTable, bias);
++ }
++
++ void QQuick3DParticleModelParticle::regenerate()
++ {
++ delete m_node;
++ m_node = nullptr;
++
++ if (!isComponentComplete() || !parentItem())
++ return;
++
++ if (!m_instanceTable) {
++ m_instanceTable = new QQuick3DParticleInstanceTable();
++ m_instanceTable->setParent(this);
++ m_instanceTable->setParentItem(this);
++ emit instanceTableChanged();
++ } else {
++ m_instanceTable->clear();
++ }
++
++ if (m_delegate.isNull())
++ return;
++
++ auto *obj = m_delegate->create(m_delegate->creationContext());
++
++ m_node = qobject_cast<QQuick3DNode *>(obj);
++ if (m_node) {
++ setInstancing(m_node, m_instanceTable, depthBias());
++ auto *particleSystem = system();
++ m_node->setParent(particleSystem);
++ m_node->setParentItem(particleSystem);
++ } else {
++ delete obj;
++ }
++ }
++
++ void QQuick3DParticleModelParticle::componentComplete()
++ {
++ if (!system() && qobject_cast<QQuick3DParticleSystem *>(parentItem()))
++ setSystem(qobject_cast<QQuick3DParticleSystem *>(parentItem()));
++
++ QQuick3DParticle::componentComplete();
++ regenerate();
++ }
++
++ void QQuick3DParticleModelParticle::itemChange(QQuick3DObject::ItemChange change, const QQuick3DObject::ItemChangeData &value)
++ {
++ QQuick3DObject::itemChange(change, value);
++ if (change == ItemParentHasChanged)
++ regenerate();
++ }
++
++ QT_END_NAMESPACE