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 <QtQuick3D/private/qquick3dquaternionutils_p.h>
++ #include "qquick3dparticlesystem_p.h"
++ #include "qquick3dparticleemitter_p.h"
++ #include "qquick3dparticletrailemitter_p.h"
++ #include "qquick3dparticlemodelparticle_p.h"
++ #include "qquick3dparticleaffector_p.h"
++ #include <private/qqmldelegatemodel_p.h>
++ #include "qquick3dparticlerandomizer_p.h"
++ #include "qquick3dparticlespriteparticle_p.h"
++ #include "qquick3dparticlelineparticle_p.h"
++ #include "qquick3dparticlemodelblendparticle_p.h"
++ #include <QtQuick3DUtils/private/qquick3dprofiler_p.h>
++ #include <qtquick3d_tracepoints_p.h>
++
++ #include <QtGui/qquaternion.h>
++
++ #include <cmath>
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \qmltype ParticleSystem3D
++ \inherits Node
++ \inqmlmodule QtQuick3D.Particles3D
++ \brief A system which includes particle, emitter, and affector types.
++ \since 6.2
++
++ This element is the root of the particle system, which handles the system timing and groups all
++ the other related elements like particles, emitters, and affectors together. To group the system
++ elements, they either need to be direct children of the ParticleSystem3D like this:
++
++ \qml,
++ ParticleSystem3D {
++ ParticleEmitter3D {
++ ...
++ }
++ SpriteParticle3D {
++ ...
++ }
++ }
++ \endqml
++
++ Or if the system elements are not direct children, they need to use \c system property to point
++ which ParticleSystem3D they belong to. Like this:
++
++ \qml
++ ParticleSystem3D {
++ id: psystem
++ }
++ ParticleEmitter3D {
++ system: psystem
++ ...
++ }
++ SpriteParticle3D {
++ system: psystem
++ ...
++ }
++ \endqml
++ */
++
++ Q_TRACE_POINT(qtquick3d, QSSG_particleUpdate_entry);
++ Q_TRACE_POINT(qtquick3d, QSSG_particleUpdate_exit, int particleCount);
++
++ QQuick3DParticleSystem::QQuick3DParticleSystem(QQuick3DNode *parent)
++ : QQuick3DNode(parent)
++ , m_running(true)
++ , m_paused(false)
++ , m_initialized(false)
++ , m_componentComplete(false)
++ , m_animation(new QQuick3DParticleSystemAnimation(this))
++ , m_updateAnimation(new QQuick3DParticleSystemUpdate(this))
++ , m_logging(false)
++ , m_loggingData(new QQuick3DParticleSystemLogging(this))
++ {
++ connect(m_loggingData, &QQuick3DParticleSystemLogging::loggingIntervalChanged, &m_loggingTimer, [this]() {
++ m_loggingTimer.setInterval(m_loggingData->m_loggingInterval);
++ });
++ // The layers property is not inherited, so forward the system's value to
++ // the internal render nodes of its particles whenever it changes.
++ connect(this, &QQuick3DNode::layersChanged, this, [this]() {
++ for (auto *particle : std::as_const(m_particles))
++ particle->updateNodeLayers();
++ });
++ }
++
++ QQuick3DParticleSystem::~QQuick3DParticleSystem()
++ {
++ m_animation->stop();
++ m_updateAnimation->stop();
++
++ for (auto &connection : std::exchange(m_connections, {}))
++ QObject::disconnect(connection);
++ // prevent each item removing itself one by one (which would be O(N²)):
++ const auto particles = std::exchange(m_particles, {});
++ const auto emitters = std::exchange(m_emitters, {});
++ const auto trailEmitters = std::exchange(m_trailEmitters, {});
++ const auto affectors = std::exchange(m_affectors, {});
++ for (auto *particle : particles)
++ particle->setSystem(nullptr);
++ for (auto *emitter : emitters)
++ emitter->setSystem(nullptr);
++ for (auto *emitter : trailEmitters)
++ emitter->setSystem(nullptr);
++ for (auto *affector : affectors)
++ affector->setSystem(nullptr);
++ }
++
++ /*!
++ \qmlproperty bool ParticleSystem3D::running
++
++ This property defines if system is currently running. If running is set to \c false,
++ the particle system will stop the simulation. All particles will be destroyed when
++ the system is set to running again.
++
++ Running should be set to \c false when manually modifying/animating the \l {ParticleSystem3D::time}{time} property.
++
++ The default value is \c true.
++ */
++ bool QQuick3DParticleSystem::isRunning() const
++ {
++ return m_running;
++ }
++
++ /*!
++ \qmlproperty bool ParticleSystem3D::paused
++
++ This property defines if system is currently paused. If paused is set to \c true, the
++ particle system will not advance the simulation. When paused is set to \c false again,
++ the simulation will resume from the same point where it was paused.
++
++ The default value is \c false.
++ */
++ bool QQuick3DParticleSystem::isPaused() const
++ {
++ return m_paused;
++ }
++
++ /*!
++ \qmlproperty int ParticleSystem3D::startTime
++
++ This property defines time in milliseconds where the system starts. This can be useful
++ to warm up the system so that a set of particles has already been emitted. If for example
++ \l startTime is set to 2000 and system \l time is animating from 0 to 1000, actually
++ animation shows particles from 2000 to 3000ms.
++
++ The default value is \c 0.
++ */
++ int QQuick3DParticleSystem::startTime() const
++ {
++ return m_startTime;
++ }
++
++ /*!
++ \qmlproperty int ParticleSystem3D::time
++
++ This property defines time in milliseconds for the system.
++ \note When modifying the time property, \l {ParticleSystem3D::running}{running}
++ should usually be set to \c false.
++
++ Here is an example how to manually animate the system for 3 seconds, in a loop, at half speed:
++
++ \qml
++ ParticleSystem3D {
++ running: false
++ NumberAnimation on time {
++ loops: Animation.Infinite
++ from: 0
++ to: 3000
++ duration: 6000
++ }
++ }
++ \endqml
++ */
++ int QQuick3DParticleSystem::time() const
++ {
++ return m_time;
++ }
++
++ /*!
++ \qmlproperty bool ParticleSystem3D::useRandomSeed
++
++ This property defines if particle system seed should be random or user defined.
++ When \c true, a new random value for \l {ParticleSystem3D::seed}{seed} is generated every time particle
++ system is restarted.
++
++ The default value is \c true.
++
++ \note This property should not be modified during the particle animations.
++
++ \sa seed
++ */
++ bool QQuick3DParticleSystem::useRandomSeed() const
++ {
++ return m_useRandomSeed;
++ }
++
++ /*!
++ \qmlproperty int ParticleSystem3D::seed
++
++ This property defines the seed value used for particles randomization. With the same seed,
++ particles effect will be identical on every run. This is useful when deterministic behavior
++ is desired over random behavior.
++
++ The default value is \c 0 when \l {ParticleSystem3D::useRandomSeed}{useRandomSeed} is set to
++ \c false, and something in between \c 1..INT32_MAX when \l {ParticleSystem3D::useRandomSeed}{useRandomSeed}
++ is set to \c true.
++
++ \note This property should not be modified during the particle animations.
++
++ \sa useRandomSeed
++ */
++ int QQuick3DParticleSystem::seed() const
++ {
++ return m_seed;
++ }
++
++ /*!
++ \qmlproperty bool ParticleSystem3D::logging
++
++ Set this to true to collect \l {ParticleSystem3D::loggingData}{loggingData}.
++
++ \note This property has some performance impact, so it should not be enabled in releases.
++
++ The default value is \c false.
++
++ \sa loggingData
++ */
++ bool QQuick3DParticleSystem::logging() const
++ {
++ return m_logging;
++ }
++
++ /*!
++ \qmlproperty ParticleSystem3DLogging ParticleSystem3D::loggingData
++ \readonly
++
++ This property contains logging data which can be useful when developing and optimizing
++ the particle effects.
++
++ \note This property contains correct data only when \l {ParticleSystem3D::logging}{logging} is set
++ to \c true and particle system is running.
++
++ \sa logging
++ */
++ QQuick3DParticleSystemLogging *QQuick3DParticleSystem::loggingData() const
++ {
++ return m_loggingData;
++ }
++
++ /*!
++ \qmlmethod void ParticleSystem3D::reset()
++
++ This method resets the internal state of the particle system to it's initial state.
++ This can be used when \l running property is \c false to reset the system.
++ The \l running is \c true this method does not need to be called as the system is managing
++ the internal state, but when it is \c false the system needs to be told when the system should
++ be reset.
++ */
++ void QQuick3DParticleSystem::reset()
++ {
++ for (auto emitter : std::as_const(m_emitters))
++ emitter->reset();
++ for (auto emitter : std::as_const(m_trailEmitters))
++ emitter->reset();
++ for (auto particle : std::as_const(m_particles))
++ particle->reset();
++ m_particleIdIndex = 0;
++ }
++
++ /*!
++ Returns the current time of the system (m_time + m_startTime).
++ \internal
++ */
++ int QQuick3DParticleSystem::currentTime() const
++ {
++ return m_currentTime;
++ }
++
++ void QQuick3DParticleSystem::setRunning(bool running)
++ {
++ if (m_running != running) {
++ m_running = running;
++ Q_EMIT runningChanged();
++ setPaused(false);
++
++ if (m_running)
++ reset();
++
++ if (m_componentComplete && !m_running && m_useRandomSeed)
++ doSeedRandomization();
++
++ (m_running && !isEditorModeOn()) ? m_animation->start() : m_animation->stop();
++ }
++ }
++
++ void QQuick3DParticleSystem::setPaused(bool paused)
++ {
++ if (m_paused != paused) {
++ m_paused = paused;
++ if (m_animation->state() != QAbstractAnimation::Stopped)
++ m_paused ? m_animation->pause() : m_animation->resume();
++ Q_EMIT pausedChanged();
++ }
++ }
++
++ void QQuick3DParticleSystem::setStartTime(int startTime)
++ {
++ if (m_startTime == startTime)
++ return;
++
++ m_startTime = startTime;
++ m_updateAnimation->setDirty(true);
++ Q_EMIT startTimeChanged();
++ }
++
++ void QQuick3DParticleSystem::setTime(int time)
++ {
++ if (m_time == time)
++ return;
++
++ // Update the time and mark the system dirty
++ m_time = time;
++ m_updateAnimation->setDirty(true);
++
++ Q_EMIT timeChanged();
++ }
++
++ void QQuick3DParticleSystem::setUseRandomSeed(bool randomize)
++ {
++ if (m_useRandomSeed == randomize)
++ return;
++
++ m_useRandomSeed = randomize;
++ // When set to true, random values are recalculated with a random seed
++ // and random values will become independent of particle index when possible.
++ if (m_useRandomSeed)
++ doSeedRandomization();
++ m_rand.setDeterministic(!m_useRandomSeed);
++ Q_EMIT useRandomSeedChanged();
++ }
++
++ void QQuick3DParticleSystem::setSeed(int seed)
++ {
++ if (m_seed == seed)
++ return;
++
++ m_seed = seed;
++ m_rand.init(m_seed);
++ Q_EMIT seedChanged();
++ }
++
++ void QQuick3DParticleSystem::setLogging(bool logging)
++ {
++ if (m_logging == logging)
++ return;
++
++ m_logging = logging;
++
++ resetLoggingVariables();
++ m_loggingData->resetData();
++
++ if (m_logging)
++ m_loggingTimer.start();
++ else
++ m_loggingTimer.stop();
++
++ Q_EMIT loggingChanged();
++ }
++
++ /*!
++ Set editor time which in editor mode overwrites the time.
++ \internal
++ */
++ void QQuick3DParticleSystem::setEditorTime(int time)
++ {
++ if (m_editorTime == time)
++ return;
++
++ // Update the time and mark the system dirty
++ m_editorTime = time;
++ m_updateAnimation->setDirty(true);
++ }
++
++ void QQuick3DParticleSystem::componentComplete()
++ {
++ QQuick3DNode::componentComplete();
++ m_componentComplete = true;
++ m_updateAnimation->start();
++
++ connect(&m_loggingTimer, &QTimer::timeout, this, &QQuick3DParticleSystem::updateLoggingData);
++ m_loggingTimer.setInterval(m_loggingData->m_loggingInterval);
++
++ if (m_useRandomSeed)
++ doSeedRandomization();
++ else
++ m_rand.init(m_seed);
++
++ m_time = 0;
++ m_currentTime = 0;
++ m_editorTime = 0;
++
++ Q_EMIT timeChanged();
++
++ // Reset restarts the animation (if running)
++ if (m_animation->state() == QAbstractAnimation::Running)
++ m_animation->stop();
++ if (m_running && !isEditorModeOn())
++ m_animation->start();
++ if (m_paused)
++ m_animation->pause();
++
++ m_initialized = true;
++ }
++
++ void QQuick3DParticleSystem::refresh()
++ {
++ // If the system isn't running, force refreshing by calling update
++ // with the current time. QAbstractAnimation::setCurrentTime() implementation
++ // always calls updateCurrentTime() even if the time would remain the same.
++ if (!m_running || m_paused || isEditorModeOn())
++ m_animation->setCurrentTime(isEditorModeOn() ? m_editorTime : m_time);
++ }
++
++ void QQuick3DParticleSystem::markDirty()
++ {
++ // Mark the system dirty so things are updated at the next frame.
++ m_updateAnimation->setDirty(true);
++ }
++
++ int QQuick3DParticleSystem::particleCount() const
++ {
++ int pCount = 0;
++ for (auto particle : std::as_const(m_particles))
++ pCount += particle->maxAmount();
++ return pCount;
++ }
++
++ void QQuick3DParticleSystem::registerParticle(QQuick3DParticle *particle)
++ {
++ m_particles << particle;
++ }
++
++ void QQuick3DParticleSystem::unRegisterParticle(QQuick3DParticle *particle)
++ {
++ m_particles.removeAll(particle);
++ }
++
++ void QQuick3DParticleSystem::registerParticleEmitter(QQuick3DParticleEmitter *e)
++ {
++ auto te = qobject_cast<QQuick3DParticleTrailEmitter *>(e);
++ if (te)
++ m_trailEmitters << te;
++ else
++ m_emitters << e;
++ }
++
++ void QQuick3DParticleSystem::unRegisterParticleEmitter(QQuick3DParticleEmitter *e)
++ {
++ auto te = qobject_cast<QQuick3DParticleTrailEmitter *>(e);
++ if (te)
++ m_trailEmitters.removeAll(te);
++ else
++ m_emitters.removeAll(e);
++ }
++
++ void QQuick3DParticleSystem::registerParticleAffector(QQuick3DParticleAffector *a)
++ {
++ m_affectors << a;
++ m_connections.insert(a, connect(a, &QQuick3DParticleAffector::update, this, &QQuick3DParticleSystem::markDirty));
++ }
++
++ void QQuick3DParticleSystem::unRegisterParticleAffector(QQuick3DParticleAffector *a)
++ {
++ QObject::disconnect(m_connections.take(a));
++ m_affectors.removeAll(a);
++ }
++
++ void QQuick3DParticleSystem::updateCurrentTime(int currentTime)
++ {
++ if (!m_initialized || isGloballyDisabled() || (isEditorModeOn() && !visible()))
++ return;
++
++ Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DParticleUpdate);
++
++ Q_TRACE(QSSG_particleUpdate_entry);
++
++ m_currentTime = currentTime;
++ const float timeS = float(m_currentTime / 1000.0f);
++
++ m_particlesMax = 0;
++ m_particlesUsed = 0;
++ m_updates++;
++
++ m_perfTimer.start();
++
++ // Emit new particles
++ for (auto emitter : std::as_const(m_emitters))
++ emitter->emitParticles();
++
++ // Prepare Affectors
++ for (auto affector : std::as_const(m_affectors)) {
++ if (affector->m_enabled)
++ affector->prepareToAffect();
++ }
++
++ // Animate current particles
++ for (auto particle : std::as_const(m_particles)) {
++
++ // Collect possible trail emits
++ QVector<TrailEmits> trailEmits;
++ for (auto emitter : std::as_const(m_trailEmitters)) {
++ if (emitter->follow() == particle) {
++ int emitAmount = emitter->getEmitAmount();
++ if (emitAmount > 0 || emitter->hasBursts()) {
++ TrailEmits e;
++ e.emitter = emitter;
++ e.amount = emitAmount;
++ trailEmits << e;
++ }
++ }
++ }
++
++ m_particlesMax += particle->maxAmount();
++
++ QQuick3DParticleSpriteParticle *spriteParticle = qobject_cast<QQuick3DParticleSpriteParticle *>(particle);
++ if (spriteParticle) {
++ processSpriteParticle(spriteParticle, trailEmits, timeS);
++ continue;
++ }
++ QQuick3DParticleModelParticle *modelParticle = qobject_cast<QQuick3DParticleModelParticle *>(particle);
++ if (modelParticle) {
++ processModelParticle(modelParticle, trailEmits, timeS);
++ continue;
++ }
++ QQuick3DParticleModelBlendParticle *mbp = qobject_cast<QQuick3DParticleModelBlendParticle *>(particle);
++ if (mbp) {
++ processModelBlendParticle(mbp, trailEmits, timeS);
++ continue;
++ }
++ }
++
++ // Clear bursts from trailemitters
++ for (auto emitter : std::as_const(m_trailEmitters))
++ emitter->clearBursts();
++
++ m_timeAnimation += m_perfTimer.nsecsElapsed();
++ m_updateAnimation->setDirty(false);
++ Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DParticleUpdate, m_particlesUsed, Q_QUICK3D_PROFILE_GET_ID(this));
++
++ Q_TRACE(QSSG_particleUpdate_exit, m_particlesUsed);
++
++ }
++
++ void QQuick3DParticleSystem::processModelParticle(QQuick3DParticleModelParticle *modelParticle, const QVector<TrailEmits> &trailEmits, float timeS)
++ {
++ modelParticle->clearInstanceTable();
++
++ const int c = modelParticle->maxAmount();
++
++ for (int i = 0; i < c; i++) {
++ const auto d = &modelParticle->m_particleData.at(i);
++
++ const float particleTimeEnd = d->startTime + d->lifetime;
++
++ if (timeS < d->startTime || timeS > particleTimeEnd) {
++ if (timeS > particleTimeEnd && d->lifetime > 0.0f) {
++ const auto pos = d->reversed ? d->startPosition : d->startPosition + (d->startVelocity * (particleTimeEnd - d->startTime));
++ for (auto trailEmit : std::as_const(trailEmits))
++ trailEmit.emitter->emitTrailParticles(pos, 0, QQuick3DParticleDynamicBurst::TriggerEnd, d->surfaceNormal, d->startVelocity.normalized());
++ }
++ // Particle not alive currently
++ continue;
++ }
++
++ QQuick3DParticleDataCurrent currentData;
++ if (timeS >= d->startTime && d->lifetime <= 0.0f) {
++ for (auto trailEmit : std::as_const(trailEmits))
++ trailEmit.emitter->emitTrailParticles(d->startPosition, 0, QQuick3DParticleDynamicBurst::TriggerStart, d->surfaceNormal, d->startVelocity.normalized());
++ }
++
++ // Adjust time for reversed particles
++ const float particleTimeS = d->reversed ? particleTimeEnd - timeS : timeS - d->startTime;
++
++ // Process features shared for both model & sprite particles
++ processParticleCommon(currentData, d, particleTimeS);
++
++ // Add a base rotation if alignment requested
++ if (modelParticle->m_alignMode != QQuick3DParticle::AlignNone)
++ processParticleAlignment(currentData, modelParticle, d);
++
++ // 0.0 -> 1.0 during the particle lifetime
++ const float timeChange = std::max(0.0f, std::min(1.0f, particleTimeS / d->lifetime));
++
++ // Scale from initial to endScale
++ currentData.scale = modelParticle->m_initialScale * (d->endSize * timeChange + d->startSize * (1.0f - timeChange));
++
++ // Fade in & out
++ const float particleTimeLeftS = d->lifetime - particleTimeS;
++ processParticleFadeInOut(currentData, modelParticle, particleTimeS, particleTimeLeftS);
++
++ // Affectors
++ for (auto affector : std::as_const(m_affectors)) {
++ // If affector is set to affect only particular particles, check these are included
++ if (affector->m_enabled && (affector->m_particles.isEmpty() || affector->m_particles.contains(modelParticle)))
++ affector->affectParticle(*d, ¤tData, particleTimeS);
++ }
++
++ // Emit new particles from trails
++ for (auto trailEmit : std::as_const(trailEmits))
++ trailEmit.emitter->emitTrailParticles(currentData.position, trailEmit.amount, QQuick3DParticleDynamicBurst::TriggerTime, d->surfaceNormal, d->startVelocity.normalized());
++
++ const QColor color(currentData.color.r, currentData.color.g, currentData.color.b, currentData.color.a);
++ // Set current particle properties
++ modelParticle->addInstance(currentData.position, currentData.scale, currentData.rotation, color, timeChange);
++ }
++ modelParticle->commitInstance();
++ }
++
++ static QVector3D mix(const QVector3D &a, const QVector3D &b, float f)
++ {
++ return (b - a) * f + a;
++ }
++
++ void QQuick3DParticleSystem::processModelBlendParticle(QQuick3DParticleModelBlendParticle *particle, const QVector<TrailEmits> &trailEmits, float timeS)
++ {
++ const int c = particle->maxAmount();
++
++ for (int i = 0; i < c; i++) {
++ const auto d = &particle->m_particleData.at(i);
++
++ const float particleTimeEnd = d->startTime + d->lifetime;
++
++ if (timeS < d->startTime || timeS > particleTimeEnd) {
++ if (timeS > particleTimeEnd && d->lifetime > 0.0f) {
++ const auto pos = d->reversed ? d->startPosition : d->startPosition + (d->startVelocity * (particleTimeEnd - d->startTime));
++ for (auto trailEmit : std::as_const(trailEmits))
++ trailEmit.emitter->emitTrailParticles(pos, 0, QQuick3DParticleDynamicBurst::TriggerEnd, d->surfaceNormal, d->startVelocity.normalized());
++ }
++ // Particle not alive currently
++ float age = 0.0f;
++ float size = 0.0f;
++ QVector3D pos;
++ QVector3D rot;
++ QVector4D color(float(d->startColor.r)/ 255.0f,
++ float(d->startColor.g)/ 255.0f,
++ float(d->startColor.b)/ 255.0f,
++ float(d->startColor.a)/ 255.0f);
++ if (d->startTime > 0.0f && timeS > particleTimeEnd
++ && (particle->modelBlendMode() == QQuick3DParticleModelBlendParticle::Construct ||
++ particle->modelBlendMode() == QQuick3DParticleModelBlendParticle::Transfer)) {
++ age = 1.0f;
++ size = 1.0f;
++ pos = particle->particleEndPosition(i);
++ rot = particle->particleEndRotation(i);
++ if (particle->fadeOutEffect() == QQuick3DParticle::FadeOpacity)
++ color.setW(0.0f);
++ } else if (particle->modelBlendMode() == QQuick3DParticleModelBlendParticle::Explode ||
++ particle->modelBlendMode() == QQuick3DParticleModelBlendParticle::Transfer) {
++ age = 0.0f;
++ size = 1.0f;
++ pos = particle->particleCenter(i);
++ if (particle->fadeInEffect() == QQuick3DParticle::FadeOpacity)
++ color.setW(0.0f);
++ }
++ particle->setParticleData(i, pos, rot, color, size, age);
++ continue;
++ }
++
++ QQuick3DParticleDataCurrent currentData;
++ if (timeS >= d->startTime && d->lifetime <= 0.0f) {
++ for (auto trailEmit : std::as_const(trailEmits))
++ trailEmit.emitter->emitTrailParticles(d->startPosition, 0, QQuick3DParticleDynamicBurst::TriggerStart, d->surfaceNormal, d->startVelocity.normalized());
++ }
++
++ // Adjust time for reversed particles
++ const float particleTimeS = d->reversed ? particleTimeEnd - timeS : timeS - d->startTime;
++
++ // Process features shared for both model & sprite particles
++ processParticleCommon(currentData, d, particleTimeS);
++
++ // 0.0 -> 1.0 during the particle lifetime
++ const float timeChange = std::max(0.0f, std::min(1.0f, particleTimeS / d->lifetime));
++
++ // Scale from initial to endScale
++ const float scale = d->endSize * timeChange + d->startSize * (1.0f - timeChange);
++ currentData.scale = QVector3D(scale, scale, scale);
++
++ // Fade in & out
++ const float particleTimeLeftS = d->lifetime - particleTimeS;
++ processParticleFadeInOut(currentData, particle, particleTimeS, particleTimeLeftS);
++
++ // Affectors
++ for (auto affector : std::as_const(m_affectors)) {
++ // If affector is set to affect only particular particles, check these are included
++ if (affector->m_enabled && (affector->m_particles.isEmpty() || affector->m_particles.contains(particle)))
++ affector->affectParticle(*d, ¤tData, particleTimeS);
++ }
++
++ // Emit new particles from trails
++ for (auto trailEmit : std::as_const(trailEmits))
++ trailEmit.emitter->emitTrailParticles(currentData.position, trailEmit.amount, QQuick3DParticleDynamicBurst::TriggerTime, d->surfaceNormal, d->startVelocity.normalized());
++
++ // Set current particle properties
++ const QVector4D color(float(currentData.color.r) / 255.0f,
++ float(currentData.color.g) / 255.0f,
++ float(currentData.color.b) / 255.0f,
++ float(currentData.color.a) / 255.0f);
++ float endTimeS = particle->endTime() * 0.001f;
++ if ((particle->modelBlendMode() == QQuick3DParticleModelBlendParticle::Construct ||
++ particle->modelBlendMode() == QQuick3DParticleModelBlendParticle::Transfer)
++ && particleTimeLeftS < endTimeS) {
++ QVector3D endPosition = particle->particleEndPosition(i);
++ QVector3D endRotation = particle->particleEndRotation(i);
++ float factor = 1.0f - particleTimeLeftS / endTimeS;
++ currentData.position = mix(currentData.position, endPosition, factor);
++ currentData.rotation = mix(currentData.rotation, endRotation, factor);
++ }
++ particle->setParticleData(i, currentData.position, currentData.rotation,
++ color, currentData.scale.x(), timeChange);
++ }
++ particle->commitParticles();
++ }
++
++ void QQuick3DParticleSystem::processSpriteParticle(QQuick3DParticleSpriteParticle *spriteParticle, const QVector<TrailEmits> &trailEmits, float timeS)
++ {
++ const int c = spriteParticle->maxAmount();
++
++ for (int i = 0; i < c; i++) {
++ const auto d = &spriteParticle->m_particleData.at(i);
++
++ const float particleTimeEnd = d->startTime + d->lifetime;
++ auto &particleData = spriteParticle->m_spriteParticleData[i];
++ if (timeS < d->startTime || timeS > particleTimeEnd) {
++ if (timeS > particleTimeEnd && particleData.age > 0.0f) {
++ const auto pos = d->reversed ? d->startPosition : d->startPosition + (d->startVelocity * (particleTimeEnd - d->startTime));
++ for (auto trailEmit : std::as_const(trailEmits))
++ trailEmit.emitter->emitTrailParticles(pos, 0, QQuick3DParticleDynamicBurst::TriggerEnd, d->surfaceNormal, d->startVelocity.normalized());
++ auto *lineParticle = qobject_cast<QQuick3DParticleLineParticle *>(spriteParticle);
++ if (lineParticle)
++ lineParticle->saveLineSegment(i, timeS);
++ }
++ // Particle not alive currently
++ spriteParticle->resetParticleData(i);
++ continue;
++ }
++
++ QQuick3DParticleDataCurrent currentData;
++ if (timeS >= d->startTime && timeS < particleTimeEnd && particleData.age == 0.0f) {
++ for (auto trailEmit : std::as_const(trailEmits))
++ trailEmit.emitter->emitTrailParticles(d->startPosition, 0, QQuick3DParticleDynamicBurst::TriggerStart, d->surfaceNormal, d->startVelocity.normalized());
++ }
++
++ // Adjust time for reversed particles
++ const float particleTimeS = d->reversed ? particleTimeEnd - timeS : timeS - d->startTime;
++
++ // Process features shared for both model & sprite particles
++ processParticleCommon(currentData, d, particleTimeS);
++
++ // Add a base rotation if alignment requested
++ if (!spriteParticle->m_billboard && spriteParticle->m_alignMode != QQuick3DParticle::AlignNone)
++ processParticleAlignment(currentData, spriteParticle, d);
++
++ // 0.0 -> 1.0 during the particle lifetime
++ const float timeChange = std::max(0.0f, std::min(1.0f, particleTimeS / d->lifetime));
++
++ // Scale from initial to endScale
++ const float scale = d->endSize * timeChange + d->startSize * (1.0f - timeChange);
++ currentData.scale = QVector3D(scale, scale, scale);
++
++ // Fade in & out
++ const float particleTimeLeftS = d->lifetime - particleTimeS;
++ processParticleFadeInOut(currentData, spriteParticle, particleTimeS, particleTimeLeftS);
++
++ float animationFrame = 0.0f;
++ if (auto sequence = spriteParticle->m_spriteSequence) {
++ // animationFrame range is [0..1) where 0.0 is the beginning of the first frame
++ // and 0.9999 is the end of the last frame.
++ const bool isSingleFrame = (sequence->animationDirection() == QQuick3DParticleSpriteSequence::SingleFrame);
++ float startFrame = sequence->firstFrame(d->index, isSingleFrame);
++ if (sequence->animationDirection() == QQuick3DParticleSpriteSequence::Normal) {
++ animationFrame = fmodf(startFrame + particleTimeS / d->animationTime, 1.0f);
++ } else if (sequence->animationDirection() == QQuick3DParticleSpriteSequence::Reverse) {
++ animationFrame = fmodf(startFrame + 0.9999f - fmodf(particleTimeS / d->animationTime, 1.0f), 1.0f);
++ } else if (sequence->animationDirection() == QQuick3DParticleSpriteSequence::Alternate) {
++ animationFrame = startFrame + particleTimeS / d->animationTime;
++ animationFrame = fabsf(fmodf(1.0f + animationFrame, 2.0f) - 1.0f);
++ } else if (sequence->animationDirection() == QQuick3DParticleSpriteSequence::AlternateReverse) {
++ animationFrame = fmodf(startFrame + 0.9999f, 1.0f) - particleTimeS / d->animationTime;
++ animationFrame = fabsf(fmodf(fabsf(1.0f + animationFrame), 2.0f) - 1.0f);
++ } else {
++ // SingleFrame
++ animationFrame = startFrame;
++ }
++ animationFrame = std::clamp(animationFrame, 0.0f, 0.9999f);
++ }
++
++ // Affectors
++ for (auto affector : std::as_const(m_affectors)) {
++ // If affector is set to affect only particular particles, check these are included
++ if (affector->m_enabled && (affector->m_particles.isEmpty() || affector->m_particles.contains(spriteParticle)))
++ affector->affectParticle(*d, ¤tData, particleTimeS);
++ }
++
++ // Emit new particles from trails
++ for (auto trailEmit : std::as_const(trailEmits))
++ trailEmit.emitter->emitTrailParticles(currentData.position, trailEmit.amount, QQuick3DParticleDynamicBurst::TriggerTime, d->surfaceNormal, d->startVelocity.normalized());
++
++
++ // Set current particle properties
++ const QVector4D color(float(currentData.color.r) / 255.0f,
++ float(currentData.color.g) / 255.0f,
++ float(currentData.color.b) / 255.0f,
++ float(currentData.color.a) / 255.0f);
++ const QVector3D offset(spriteParticle->offsetX(), spriteParticle->offsetY(), 0);
++ spriteParticle->setParticleData(i, currentData.position + (offset * currentData.scale.x()),
++ currentData.rotation, color, currentData.scale.x(), timeChange,
++ animationFrame);
++ }
++ spriteParticle->commitParticles(timeS);
++ }
++
++ void QQuick3DParticleSystem::processParticleCommon(QQuick3DParticleDataCurrent ¤tData, const QQuick3DParticleData *d, float particleTimeS)
++ {
++ m_particlesUsed++;
++
++ currentData.position = d->startPosition;
++
++ // Initial color from start color
++ currentData.color = d->startColor;
++
++ // Initial position from start velocity
++ currentData.position += d->startVelocity * particleTimeS;
++
++ // Initial rotation from start velocity
++ constexpr float step = 360.0f / 127.0f;
++ currentData.rotation = QVector3D(
++ d->startRotation.x * step + abs(d->startRotationVelocity.x) * d->startRotationVelocity.x * particleTimeS,
++ d->startRotation.y * step + abs(d->startRotationVelocity.y) * d->startRotationVelocity.y * particleTimeS,
++ d->startRotation.z * step + abs(d->startRotationVelocity.z) * d->startRotationVelocity.z * particleTimeS);
++ }
++
++ void QQuick3DParticleSystem::processParticleFadeInOut(QQuick3DParticleDataCurrent ¤tData, const QQuick3DParticle *particle, float particleTimeS, float particleTimeLeftS)
++ {
++ const float fadeInS = particle->m_fadeInDuration / 1000.0f;
++ const float fadeOutS = particle->m_fadeOutDuration / 1000.0f;
++ if (particleTimeS < fadeInS) {
++ // 0.0 -> 1.0 during the particle fadein
++ const float fadeIn = particleTimeS / fadeInS;
++ if (particle->m_fadeInEffect == QQuick3DParticleModelParticle::FadeOpacity)
++ currentData.color.a *= fadeIn;
++ else if (particle->m_fadeInEffect == QQuick3DParticleModelParticle::FadeScale)
++ currentData.scale *= fadeIn;
++ }
++ if (particleTimeLeftS < fadeOutS) {
++ // 1.0 -> 0.0 during the particle fadeout
++ const float fadeOut = particleTimeLeftS / fadeOutS;
++ if (particle->m_fadeOutEffect == QQuick3DParticleModelParticle::FadeOpacity)
++ currentData.color.a *= fadeOut;
++ else if (particle->m_fadeOutEffect == QQuick3DParticleModelParticle::FadeScale)
++ currentData.scale *= fadeOut;
++ }
++ }
++
++ void QQuick3DParticleSystem::processParticleAlignment(QQuick3DParticleDataCurrent ¤tData, const QQuick3DParticle *particle, const QQuick3DParticleData *d)
++ {
++ if (particle->m_alignMode == QQuick3DParticle::AlignTowardsTarget) {
++ QQuaternion alignQuat = QQuick3DQuaternionUtils::lookAt(particle->alignTargetPosition(), currentData.position);
++ currentData.rotation = (alignQuat * QQuaternion::fromEulerAngles(currentData.rotation)).toEulerAngles();
++ } else if (particle->m_alignMode == QQuick3DParticle::AlignTowardsStartVelocity) {
++ QQuaternion alignQuat = QQuick3DQuaternionUtils::lookAt(d->startVelocity, QVector3D());
++ currentData.rotation = (alignQuat * QQuaternion::fromEulerAngles(currentData.rotation)).toEulerAngles();
++ }
++ }
++
++ bool QQuick3DParticleSystem::isGloballyDisabled()
++ {
++ static const bool disabled = qEnvironmentVariableIntValue("QT_QUICK3D_DISABLE_PARTICLE_SYSTEMS");
++ return disabled;
++ }
++
++ bool QQuick3DParticleSystem::isEditorModeOn()
++ {
++ static const bool editorMode = qEnvironmentVariableIntValue("QT_QUICK3D_EDITOR_PARTICLE_SYSTEMS");
++ return editorMode;
++ }
++
++ void QQuick3DParticleSystem::updateLoggingData()
++ {
++ if (m_updates == 0)
++ return;
++
++ if (m_loggingData->m_particlesMax != m_particlesMax) {
++ m_loggingData->m_particlesMax = m_particlesMax;
++ Q_EMIT m_loggingData->particlesMaxChanged();
++ }
++ if (m_loggingData->m_particlesUsed != m_particlesUsed) {
++ m_loggingData->m_particlesUsed = m_particlesUsed;
++ Q_EMIT m_loggingData->particlesUsedChanged();
++ }
++ if (m_loggingData->m_updates != m_updates) {
++ m_loggingData->m_updates = m_updates;
++ Q_EMIT m_loggingData->updatesChanged();
++ }
++
++ m_loggingData->updateTimes(m_timeAnimation);
++
++ Q_EMIT loggingDataChanged();
++ resetLoggingVariables();
++ }
++
++ void QQuick3DParticleSystem::resetLoggingVariables()
++ {
++ m_particlesMax = 0;
++ m_particlesUsed = 0;
++ m_updates = 0;
++ m_timeAnimation = 0;
++ }
++
++ QPRand *QQuick3DParticleSystem::rand()
++ {
++ return &m_rand;
++ }
++
++ void QQuick3DParticleSystem::doSeedRandomization()
++ {
++ // Random 1..INT32_MAX, making sure seed changes from the initial 0.
++ setSeed(QRandomGenerator::global()->bounded(1 + (INT32_MAX - 1)));
++ }
++
++ bool QQuick3DParticleSystem::isShared(const QQuick3DParticle *particle) const
++ {
++ int count = 0;
++ for (auto emitter : std::as_const(m_emitters)) {
++ count += emitter->particle() == particle;
++ if (count > 1)
++ return true;
++ }
++ for (auto emitter : std::as_const(m_trailEmitters)) {
++ count += emitter->particle() == particle;
++ if (count > 1)
++ return true;
++ }
++ return false;
++ }
++
++ QT_END_NAMESPACE