qquick3dparticleemitter.cpp

Go to the documentation of this file.

// 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 "qquick3dparticleemitter_p.h"
#include "qquick3dparticlemodelparticle_p.h"
#include "qquick3dparticlerandomizer_p.h"
#include "qquick3dparticleutils_p.h"
#include "qquick3dparticlespritesequence_p.h"
#include "qquick3dparticlemodelblendparticle_p.h"
 
#include <QtGui/qquaternion.h>
 
QT_BEGIN_NAMESPACE
 
/*!
    \qmltype ParticleEmitter3D
    \inherits Node
    \inqmlmodule QtQuick3D.Particles3D
    \brief Emitter for logical particles.
    \since 6.2
 
    This element emits logical particles into the \l ParticleSystem3D, with the given starting attributes.
 
    At least one emitter is required to have particles in the \l ParticleSystem3D. There are a few different
    ways to control the emitting amount:
    \list
        \li Set the \l emitRate which controls how many particles per second get emitted continuously.
        \li Add \l EmitBurst3D elements into emitBursts property to emit bursts declaratively.
        \li Call any of the \l burst() methods to emit bursts immediately.
    \endlist
*/
 
template <typename T,
         typename std::enable_if_t<std::is_signed_v<T>, bool> = true,
         typename std::enable_if_t<std::is_arithmetic_v<T>, bool> = true>
static constexpr T qSign(T val)
{
    return val < T(0) ? T(-1) : T(1);
}
 
QQuick3DParticleEmitter::QQuick3DParticleEmitter(QQuick3DNode *parent)
    : QQuick3DNode(parent)
{
}
 
QQuick3DParticleEmitter::~QQuick3DParticleEmitter()
{
    qDeleteAll(m_emitBursts);
    m_emitBursts.clear();
    if (m_system)
        m_system->unRegisterParticleEmitter(this);
}
 
/*!
    \qmlproperty bool ParticleEmitter3D::enabled
 
    If enabled is set to \c false, this emitter will not emit any particles.
    Usually this is used to conditionally turn an emitter on or off.
    If you want to continue emitting burst, keep \l emitRate at 0 instead of
    toggling this to \c false.
 
    The default value is \c true.
*/
bool QQuick3DParticleEmitter::enabled() const
{
    return m_enabled;
}
void QQuick3DParticleEmitter::setEnabled(bool enabled)
{
    if (m_enabled == enabled)
        return;
 
    if (enabled && m_system) {
        // When enabling, we need to reset the
        // previous emit time as it might be a long time ago.
        m_prevEmitTime = m_system->currentTime();
        m_prevBurstTime = m_prevEmitTime;
    }
 
    m_enabled = enabled;
    Q_EMIT enabledChanged();
}
 
/*!
    \qmlproperty Direction3D ParticleEmitter3D::velocity
 
    This property can be used to set a starting velocity for emitted particles.
    If velocity is not set, particles start motionless and velocity comes from
    \l {Affector3D}{affectors} if they are used.
*/
QQuick3DParticleDirection *QQuick3DParticleEmitter::velocity() const
{
    return m_velocity;
}
 
void QQuick3DParticleEmitter::setVelocity(QQuick3DParticleDirection *velocity)
{
    if (m_velocity == velocity)
        return;
 
    m_velocity = velocity;
    if (m_velocity && m_system)
        m_velocity->m_system = m_system;
 
    Q_EMIT velocityChanged();
}
 
/*!
    \qmlproperty ParticleSystem3D ParticleEmitter3D::system
 
    This property defines the \l ParticleSystem3D for the emitter. If system is direct parent of the emitter,
    this property does not need to be defined.
*/
QQuick3DParticleSystem *QQuick3DParticleEmitter::system() const
{
    return m_system;
}
 
void QQuick3DParticleEmitter::setSystem(QQuick3DParticleSystem *system)
{
    if (m_system == system)
        return;
 
    if (m_system)
        m_system->unRegisterParticleEmitter(this);
 
    m_system = system;
    if (m_system) {
        m_system->registerParticleEmitter(this);
        // Reset prev emit time to time of the new system
        m_prevEmitTime = m_system->currentTime();
        m_prevBurstTime = m_prevEmitTime;
    }
 
    if (m_particle)
        m_particle->setSystem(m_system);
 
    if (m_shape)
        m_shape->m_system = m_system;
 
    if (m_velocity)
        m_velocity->m_system = m_system;
 
    m_systemSharedParent = getSharedParentNode(this, m_system);
 
    Q_EMIT systemChanged();
}
 
/*!
    \qmlproperty real ParticleEmitter3D::emitRate
 
    This property defines the constant emitting rate in particles per second.
    For example, if the emitRate is 120 and system animates at 60 frames per
    second, 2 new particles are emitted at every frame.
 
    The default value is \c 0.
*/
float QQuick3DParticleEmitter::emitRate() const
{
    return m_emitRate;
}
 
void QQuick3DParticleEmitter::setEmitRate(float emitRate)
{
    if (qFuzzyCompare(m_emitRate, emitRate))
        return;
 
    if (m_emitRate == 0 && m_system) {
        // When changing emit rate from 0 we need to reset
        // previous emit time as it may be long time ago
        m_prevEmitTime = m_system->currentTime();
    }
    m_emitRate = emitRate;
    Q_EMIT emitRateChanged();
}
 
 
/*!
    \qmlproperty real ParticleEmitter3D::particleScale
 
    This property defines the scale multiplier of the particles at the beginning.
    To have variation in the particle sizes, use \l particleScaleVariation.
 
    The default value is \c 1.0.
 
    \sa particleEndScale, particleScaleVariation
*/
float QQuick3DParticleEmitter::particleScale() const
{
    return m_particleScale;
}
 
void QQuick3DParticleEmitter::setParticleScale(float particleScale)
{
    if (qFuzzyCompare(m_particleScale, particleScale))
        return;
 
    m_particleScale = particleScale;
    Q_EMIT particleScaleChanged();
}
 
/*!
    \qmlproperty real ParticleEmitter3D::particleEndScale
 
    This property defines the scale multiplier of the particles at the end
    of particle \l lifeSpan. To have variation in the particle end sizes, use
    \l particleEndScaleVariation. When the value is negative, end scale is the
    same as the \l particleScale, so scale doesn't change during the particle
    \l lifeSpan.
 
    The default value is \c -1.0.
 
    \sa particleScale, particleScaleVariation
*/
float QQuick3DParticleEmitter::particleEndScale() const
{
    return m_particleEndScale;
}
 
void QQuick3DParticleEmitter::setParticleEndScale(float particleEndScale)
{
    if (qFuzzyCompare(m_particleEndScale, particleEndScale))
        return;
 
    m_particleEndScale = particleEndScale;
    Q_EMIT particleEndScaleChanged();
}
 
/*!
    \qmlproperty real ParticleEmitter3D::particleScaleVariation
 
    This property defines the scale variation of the particles. For example, to
    emit particles at scale 0.5 - 1.5:
 
    \qml
    ParticleEmitter3D {
        ...
        particleScale: 1.0
        particleScaleVariation: 0.5
    }
    \endqml
 
    The default value is \c 0.0.
 
    \sa particleScale, particleEndScaleVariation
*/
float QQuick3DParticleEmitter::particleScaleVariation() const
{
    return m_particleScaleVariation;
}
 
void QQuick3DParticleEmitter::setParticleScaleVariation(float particleScaleVariation)
{
    if (qFuzzyCompare(m_particleScaleVariation, particleScaleVariation))
        return;
 
    m_particleScaleVariation = particleScaleVariation;
    Q_EMIT particleScaleVariationChanged();
}
 
/*!
    \qmlproperty real ParticleEmitter3D::particleEndScaleVariation
 
    This property defines the scale variation of the particles in the end.
    When the value is negative, \l particleScaleVariation is used also for the
    end scale. For example, to emit particles which start at scale 0.5 - 1.5 and end
    at scale 1.0 - 5.0:
 
    \qml
    ParticleEmitter3D {
        ...
        particleScale: 1.0
        particleScaleVariation: 0.5
        particleEndScale: 3.0
        particleEndScaleVariation: 2.0
    }
    \endqml
 
    The default value is \c -1.0.
 
    \sa particleEndScale
*/
float QQuick3DParticleEmitter::particleEndScaleVariation() const
{
    return m_particleEndScaleVariation;
}
 
void QQuick3DParticleEmitter::setParticleEndScaleVariation(float particleEndScaleVariation)
{
    if (qFuzzyCompare(m_particleEndScaleVariation, particleEndScaleVariation))
        return;
 
    m_particleEndScaleVariation = particleEndScaleVariation;
    Q_EMIT particleEndScaleVariationChanged();
}
 
/*!
    \qmlproperty int ParticleEmitter3D::lifeSpan
 
    This property defines the lifespan of a single particle in milliseconds.
 
    The default value is \c 1000.
 
    \sa lifeSpanVariation
*/
int QQuick3DParticleEmitter::lifeSpan() const
{
    return m_lifeSpan;
}
 
void QQuick3DParticleEmitter::setLifeSpan(int lifeSpan)
{
    if (m_lifeSpan == lifeSpan)
        return;
 
    m_lifeSpan = lifeSpan;
    Q_EMIT lifeSpanChanged();
}
 
/*!
    \qmlproperty int ParticleEmitter3D::lifeSpanVariation
 
    This property defines the lifespan variation of a single particle in milliseconds.
 
    For example, to emit particles which will exist between 3 and 4 seconds:
 
    \qml
    ParticleEmitter3D {
        ...
        lifeSpan: 3500
        lifeSpanVariation: 500
    }
    \endqml
 
    The default value is \c 0.
 
    \sa lifeSpan
*/
int QQuick3DParticleEmitter::lifeSpanVariation() const
{
    return m_lifeSpanVariation;
}
 
void QQuick3DParticleEmitter::setLifeSpanVariation(int lifeSpanVariation)
{
    if (m_lifeSpanVariation == lifeSpanVariation)
        return;
 
    m_lifeSpanVariation = lifeSpanVariation;
    Q_EMIT lifeSpanVariationChanged();
}
 
/*!
    \qmlproperty Particle3D ParticleEmitter3D::particle
 
    This property defines the logical particle which this emitter emits.
    Emitter must have a particle defined, or it doesn't emit anything.
    Particle can be either \l SpriteParticle3D or \l ModelParticle3D.
*/
QQuick3DParticle *QQuick3DParticleEmitter::particle() const
{
    return m_particle;
}
 
void QQuick3DParticleEmitter::setParticle(QQuick3DParticle *particle)
{
    if (m_particle == particle)
        return;
    if (particle && particle->system() != nullptr && m_system && particle->system() != m_system) {
        qWarning("ParticleEmitter3D: Emitter and Particle must be in the same system.");
        return;
    }
 
    if (m_particle && m_system && !m_system->isShared(m_particle))
        m_particle->setSystem(nullptr);
    m_particle = particle;
    if (particle) {
        particle->setDepthBias(m_depthBias);
        particle->setSystem(system());
        QObject::connect(this, &QQuick3DParticleEmitter::depthBiasChanged, m_particle, [this]() {
            m_particle->setDepthBias(m_depthBias);
        });
    }
    Q_EMIT particleChanged();
}
 
/*!
    \qmlproperty ParticleAbstractShape3D ParticleEmitter3D::shape
 
    This property defines optional shape for the emitting area. It can be either
    \l ParticleShape3D or \l ParticleModelShape3D. Shape is scaled,
    positioned and rotated based on the emitter node properties. When the Shape
    \l {ParticleShape3D::fill}{fill} property is set to false, emitting happens
    only from the surface of the shape.
 
    When the shape is not defined, emitting is done from the center point of the
    emitter node.
*/
QQuick3DParticleAbstractShape *QQuick3DParticleEmitter::shape() const
{
    return m_shape;
}
 
void QQuick3DParticleEmitter::setShape(QQuick3DParticleAbstractShape *shape)
{
    if (m_shape == shape)
        return;
 
    m_shape = shape;
    if (m_shape && m_system)
        m_shape->m_system = m_system;
    Q_EMIT shapeChanged();
}
 
/*!
    \qmlproperty vector3d ParticleEmitter3D::particleRotation
 
    This property defines the rotation of the particles in the beginning.
    Rotation is defined as degrees in euler angles.
 
    \sa particleRotationVariation
*/
QVector3D QQuick3DParticleEmitter::particleRotation() const
{
    return m_particleRotation;
}
 
void QQuick3DParticleEmitter::setParticleRotation(const QVector3D &particleRotation)
{
    if (m_particleRotation == particleRotation)
        return;
 
    m_particleRotation = particleRotation;
    Q_EMIT particleRotationChanged();
}
 
/*!
    \qmlproperty vector3d ParticleEmitter3D::particleRotationVariation
 
    This property defines the rotation variation of the particles in the beginning.
    Rotation variation is defined as degrees in euler angles.
 
    For example, to emit particles in fully random rotations:
 
    \qml
    ParticleEmitter3D {
        ...
        particleRotationVariation: Qt.vector3d(180, 180, 180)
    }
    \endqml
 
    \sa particleRotation
*/
QVector3D QQuick3DParticleEmitter::particleRotationVariation() const
{
    return m_particleRotationVariation;
}
 
void QQuick3DParticleEmitter::setParticleRotationVariation(const QVector3D &particleRotationVariation)
{
    if (m_particleRotationVariation == particleRotationVariation)
        return;
 
    m_particleRotationVariation = particleRotationVariation;
    Q_EMIT particleRotationVariationChanged();
}
 
/*!
    \qmlproperty vector3d ParticleEmitter3D::particleRotationVelocity
 
    This property defines the rotation velocity of the particles in the beginning.
    Rotation velocity is defined as degrees per second in euler angles.
 
    \sa particleRotationVelocityVariation
*/
QVector3D QQuick3DParticleEmitter::particleRotationVelocity() const
{
    return m_particleRotationVelocity;
}
 
void QQuick3DParticleEmitter::setParticleRotationVelocity(const QVector3D &particleRotationVelocity)
{
    if (m_particleRotationVelocity == particleRotationVelocity)
        return;
 
    m_particleRotationVelocity = particleRotationVelocity;
    Q_EMIT particleRotationVelocityChanged();
}
 
/*!
    \qmlproperty vector3d ParticleEmitter3D::particleRotationVelocityVariation
 
    This property defines the rotation velocity variation of the particles.
    Rotation velocity variation is defined as degrees per second in euler angles.
 
    For example, to emit particles in random rotations which have random rotation
    velocity between -100 and 100 degrees per second into any directions:
 
    \qml
    ParticleEmitter3D {
        ...
        particleRotationVariation: Qt.vector3d(180, 180, 180)
        particleRotationVelocityVariation: Qt.vector3d(100, 100, 100)
    }
    \endqml
 
    \sa particleRotationVelocity
*/
QVector3D QQuick3DParticleEmitter::particleRotationVelocityVariation() const
{
    return m_particleRotationVelocityVariation;
}
 
void QQuick3DParticleEmitter::setParticleRotationVelocityVariation(const QVector3D &particleRotationVelocityVariation)
{
    if (m_particleRotationVelocityVariation == particleRotationVelocityVariation)
        return;
 
    m_particleRotationVelocityVariation = particleRotationVelocityVariation;
    Q_EMIT particleRotationVariationVelocityChanged();
}
 
/*!
    \qmlproperty real ParticleEmitter3D::depthBias
 
    Holds the depth bias of the emitter. 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 QQuick3DParticleEmitter::depthBias() const
{
    return m_depthBias;
}
 
void QQuick3DParticleEmitter::setDepthBias(float bias)
{
    if (qFuzzyCompare(bias, m_depthBias))
        return;
 
    m_depthBias = bias;
    emit depthBiasChanged();
}
 
/*!
    \qmlproperty bool ParticleEmitter3D::reversed
    \since 6.10
 
    This property reverses the particle time i.e. emitted particles are run from
    the end time to the start time.
    \default false
*/
bool QQuick3DParticleEmitter::reversed() const
{
    return m_reversed;
}
 
void QQuick3DParticleEmitter::setReversed(bool reversed)
{
    if (m_reversed == reversed)
        return;
    m_reversed = reversed;
    emit reversedChanged();
}
 
/*!
    \qmlproperty EmitMode ParticleEmitter3D::emitMode
    \since 6.10
 
    This property defines the emit mode of the emitter with shape.
 
    \default ParticleEmitter3D.Default
*/
 
/*!
    \qmlproperty enumeration ParticleEmitter3D::EmitMode
    \since 6.10
 
    Defines the emit mode of the emitter with shape.
 
    \value ParticleEmitter3D.Default
        Default emit behavior.
    \value ParticleEmitter3D.SurfaceNormal
        The particles are emitted along the surface normal. Requires a particle shape.
        If the emitter is a trail emitter, the surface normal is inherited from the followed particle.
    \value ParticleEmitter3D.SurfaceReflected
        The particles are emitted along the reflection of the velocity vector and the surface normal.
        If the emitter is a trail emitter, the surface normal and the velocity are inherited from the followed particle.
        Requires particle shape.
*/
 
QQuick3DParticleEmitter::EmitMode QQuick3DParticleEmitter::emitMode() const
{
    return m_emitMode;
}
 
void QQuick3DParticleEmitter::setEmitMode(EmitMode mode)
{
    if (m_emitMode == mode)
        return;
    m_emitMode = mode;
    emit emitModeChanged();
}
 
// Called to reset when system stop/continue
void QQuick3DParticleEmitter::reset()
{
    m_prevEmitTime = 0;
    m_unemittedF = 0.0f;
    m_prevBurstTime = 0;
    m_burstEmitData.clear();
}
 
/*!
    \qmlmethod vector3d ParticleEmitter3D::burst(int count)
 
    This method emits \a count amount of particles from this emitter immediately.
*/
void QQuick3DParticleEmitter::burst(int count)
{
    burst(count, 0, QVector3D());
}
 
/*!
    \qmlmethod vector3d ParticleEmitter3D::burst(int count, int duration)
 
    This method emits \a count amount of particles from this emitter during the
    next \a duration milliseconds.
*/
void QQuick3DParticleEmitter::burst(int count, int duration)
{
    burst(count, duration, QVector3D());
}
 
/*!
    \qmlmethod vector3d ParticleEmitter3D::burst(int count, int duration, vector3d position)
 
    This method emits \a count amount of particles from this emitter during the
    next \a duration milliseconds. The particles are emitted as if the emitter was
    at \a position but all other properties are the same.
*/
void QQuick3DParticleEmitter::burst(int count, int duration, const QVector3D &position)
{
    if (!m_system)
        return;
    QQuick3DParticleEmitBurstData burst;
    burst.time = m_system->currentTime();
    burst.amount = count;
    burst.duration = duration;
    burst.position = position;
    emitParticlesBurst(burst);
}
 
void QQuick3DParticleEmitter::generateEmitBursts()
{
    if (!m_system)
        return;
 
    if (!m_particle)
        return;
 
    if (m_emitBursts.isEmpty()) {
        m_burstGenerated = true;
        return;
    }
 
    // Generating burst causes all particle data reseting
    // as bursts take first particles in the list.
    m_particle->reset();
 
    // TODO: In trail emitter case centerPos should be calculated
    // taking into account each particle position at emitburst time
    QMatrix4x4 transform = calculateParticleTransform(parentNode(), m_systemSharedParent);
    QQuaternion rotation = calculateParticleRotation(parentNode(), m_systemSharedParent);
    QVector3D centerPos = position();
 
    for (auto emitBurst : std::as_const(m_emitBursts)) {
        // Ignore all dynamic bursts here
        if (qobject_cast<QQuick3DParticleDynamicBurst *>(emitBurst))
            continue;
        int emitAmount = emitBurst->amount();
        if (emitAmount <= 0)
            return;
        // Distribute start times between burst time and time+duration.
        float startTime = float(emitBurst->time() / 1000.0f);
        float timeStep = float(emitBurst->duration() / 1000.0f) / emitAmount;
        for (int i = 0; i < emitAmount; i++) {
            emitParticle(m_particle, startTime, transform, rotation, centerPos);
            startTime += timeStep;
        }
        // Increase burst index (for statically allocated particles)
        m_particle->updateBurstIndex(emitBurst->amount());
    }
    m_burstGenerated = true;
}
 
void QQuick3DParticleEmitter::registerEmitBurst(QQuick3DParticleEmitBurst* emitBurst)
{
    m_emitBursts.removeAll(emitBurst);
    m_emitBursts << emitBurst;
    m_burstGenerated = false;
}
 
void QQuick3DParticleEmitter::unRegisterEmitBurst(QQuick3DParticleEmitBurst* emitBurst)
{
    m_emitBursts.removeAll(emitBurst);
    m_burstGenerated = false;
}
 
static QMatrix4x4 rotationFromNormal(const QVector3D &n)
{
    static QMatrix4x4 s_cached;
    static QVector3D s_cachedN;
    if (qFuzzyCompare(s_cachedN.x(), n.x()) && qFuzzyCompare(s_cachedN.y(), n.y()) && qFuzzyCompare(s_cachedN.z(), n.z()))
        return s_cached;
    QVector3D b;
    QVector3D t;
    float values[16];
 
    if (qAbs(n.y()) < 1.0f - 0.0001f) {
        t = QVector3D::crossProduct(n, QVector3D(0, qSign(n.y()), 0));
        b = QVector3D::crossProduct(n, t);
    } else {
        b = QVector3D(1, 0, 0);
        t = QVector3D(0, 0, 1);
    }
    values[0] = b.x();
    values[1] = b.y();
    values[2] = b.z();
    values[3] = 0.0;
    values[4] = t.x();
    values[5] = t.y();
    values[6] = t.z();
    values[7] = 0.0;
    values[8] = n.x();
    values[9] = n.y();
    values[10] = n.z();
    values[11] = 0.0;
    values[12] = 0.0;
    values[13] = 0.0;
    values[14] = 0.0;
    values[15] = 1.0;
    QMatrix4x4 ret = QMatrix4x4(values);
    s_cached = ret.transposed();
    s_cachedN = n;
    return s_cached;
}
 
static QVector3D reflect(const QVector3D &I, QVector3D &N)
{
    return I - 2.0 * QVector3D::dotProduct(N, I) * N;
}
 
void QQuick3DParticleEmitter::emitParticle(QQuick3DParticle *particle, float startTime, const QMatrix4x4 &transform,
                                           const QQuaternion &parentRotation, const QVector3D &centerPos, int index,
                                           const QVector3D &velocity, const QVector3D &normal)
{
    if (!m_system)
        return;
    auto rand = m_system->rand();
 
    QQuick3DParticleModelBlendParticle *mbp = qobject_cast<QQuick3DParticleModelBlendParticle *>(particle);
    if (mbp && mbp->lastParticle())
        return;
 
    int particleDataIndex = index == -1 ? particle->nextCurrentIndex(this) : index;
    if (index == -1 && mbp && mbp->emitMode() == QQuick3DParticleModelBlendParticle::Random)
        particleDataIndex = mbp->randomIndex(particleDataIndex);
 
    auto d = &particle->m_particleData[particleDataIndex];
    int particleIdIndex = m_system->m_particleIdIndex++;
    if (m_system->m_particleIdIndex == INT_MAX)
        m_system->m_particleIdIndex = 0;
 
    *d = m_clearData; // Reset the data as it might be reused
    d->index = particleIdIndex;
    d->startTime = startTime;
    d->surfaceNormal = normal;
 
    // Life time in seconds
    float lifeSpanMs = m_lifeSpanVariation / 1000.0f;
    float lifeSpanVariationMs = lifeSpanMs - 2.0f * rand->get(particleIdIndex, QPRand::LifeSpanV) * lifeSpanMs;
    d->lifetime = (m_lifeSpan / 1000.0f) + lifeSpanVariationMs;
 
    // Size
    float sVar = m_particleScaleVariation - 2.0f * rand->get(particleIdIndex, QPRand::ScaleV) * m_particleScaleVariation;
    float endScale = (m_particleEndScale < 0.0f) ? m_particleScale : m_particleEndScale;
    float sEndVar = (m_particleEndScaleVariation < 0.0f)
            ? sVar
            : m_particleEndScaleVariation - 2.0f * rand->get(particleIdIndex, QPRand::ScaleEV) * m_particleEndScaleVariation;
    d->startSize = std::max(0.0f, float(m_particleScale + sVar));
    d->endSize = std::max(0.0f, float(endScale + sEndVar));
 
    // Emiting area/shape
    bool normalBasedVelocity = false;
    if (mbp && mbp->modelBlendMode() != QQuick3DParticleModelBlendParticle::Construct) {
        // We emit from model position unless in construct mode
        d->startPosition = mbp->particleCenter(particleDataIndex);
    } else {
        // When shape is not set, default to node center point.
        QVector3D pos = centerPos;
        if (m_shape) {
            pos += m_shape->getPosition(particleIdIndex);
            const auto n = m_shape->getSurfaceNormal(particleIdIndex);
            if (!n.isNull()) {
                d->surfaceNormal = n;
                if (m_emitMode != EmitMode::Default)
                    normalBasedVelocity = true;
            }
        } else if (!normal.isNull() && m_emitMode != EmitMode::Default) {
            normalBasedVelocity = true;
        }
        d->startPosition = transform.map(pos);
    }
 
    // Velocity
    // Rotate velocity based on parent node rotation and emitter rotation
    if (m_velocity)
        d->startVelocity = parentRotation * rotation() * m_velocity->sample(*d);
    if (normalBasedVelocity) {
        if (m_emitMode == EmitMode::SurfaceNormal)
            d->startVelocity = rotationFromNormal(d->surfaceNormal).mapVector(d->startVelocity);
        else if (!velocity.isNull()) // EmitMode::SurfaceReflected
            d->startVelocity = rotationFromNormal(-reflect(velocity, d->surfaceNormal)).mapVector(d->startVelocity);
        else
            d->startVelocity = rotationFromNormal(-reflect(d->startVelocity.normalized(), d->surfaceNormal)).mapVector(d->startVelocity);
    }
 
    // Rotation
    if (!m_particleRotation.isNull() || !m_particleRotationVariation.isNull()) {
        Vector3b rot;
        constexpr float step = 127.0f / 360.0f; // +/- 360-degrees as qint8 (-127..127)
        rot.x = m_particleRotation.x() * step;
        rot.y = m_particleRotation.y() * step;
        rot.z = m_particleRotation.z() * step;
        rot.x += (m_particleRotationVariation.x() - 2.0f * rand->get(particleIdIndex, QPRand::RotXV) * m_particleRotationVariation.x()) * step;
        rot.y += (m_particleRotationVariation.y() - 2.0f * rand->get(particleIdIndex, QPRand::RotYV) * m_particleRotationVariation.y()) * step;
        rot.z += (m_particleRotationVariation.z() - 2.0f * rand->get(particleIdIndex, QPRand::RotZV) * m_particleRotationVariation.z()) * step;
        d->startRotation = rot;
    }
    // Rotation velocity
    if (!m_particleRotationVelocity.isNull() || !m_particleRotationVelocityVariation.isNull()) {
        float rotVelX = m_particleRotationVelocity.x();
        float rotVelY = m_particleRotationVelocity.y();
        float rotVelZ = m_particleRotationVelocity.z();
        rotVelX += (m_particleRotationVelocityVariation.x() - 2.0f * rand->get(particleIdIndex, QPRand::RotXVV) * m_particleRotationVelocityVariation.x());
        rotVelY += (m_particleRotationVelocityVariation.y() - 2.0f * rand->get(particleIdIndex, QPRand::RotYVV) * m_particleRotationVelocityVariation.y());
        rotVelZ += (m_particleRotationVelocityVariation.z() - 2.0f * rand->get(particleIdIndex, QPRand::RotZVV) * m_particleRotationVelocityVariation.z());
        // Particle data rotations are in qint8 vec3 to save memory.
        // max value 127*127 = 16129 degrees/second
        float sign;
        sign = rotVelX < 0.0f ? -1.0f : 1.0f;
        rotVelX = std::max(-127.0f, std::min<float>(127.0f, sign * std::sqrt(abs(rotVelX))));
        sign = rotVelY < 0.0f ? -1.0f : 1.0f;
        rotVelY = std::max(-127.0f, std::min<float>(127.0f, sign * std::sqrt(abs(rotVelY))));
        sign = rotVelZ < 0.0f ? -1.0f : 1.0f;
        rotVelZ = std::max(-127.0f, std::min<float>(127.0f, sign * std::sqrt(abs(rotVelZ))));
        d->startRotationVelocity = { qint8(rotVelX), qint8(rotVelY), qint8(rotVelZ) };
    }
 
    // Colors
    QColor pc = particle->color();
    QVector4D pcv = particle->colorVariation();
    uchar r, g, b, a;
    if (particle->unifiedColorVariation()) {
        // Vary all color channels using the same random amount
        const int randVar = int(rand->get(particleIdIndex, QPRand::ColorAV) * 256);
        r = pc.red() * (1.0f - pcv.x()) + randVar * pcv.x();
        g = pc.green() * (1.0f - pcv.y()) + randVar * pcv.y();
        b = pc.blue() * (1.0f - pcv.z()) + randVar * pcv.z();
        a = pc.alpha() * (1.0f - pcv.w()) + randVar * pcv.w();
    } else {
        r = pc.red() * (1.0f - pcv.x()) + int(rand->get(particleIdIndex, QPRand::ColorRV) * 256) * pcv.x();
        g = pc.green() * (1.0f - pcv.y()) + int(rand->get(particleIdIndex, QPRand::ColorGV) * 256) * pcv.y();
        b = pc.blue() * (1.0f - pcv.z()) + int(rand->get(particleIdIndex, QPRand::ColorBV) * 256) * pcv.z();
        a = pc.alpha() * (1.0f - pcv.w()) + int(rand->get(particleIdIndex, QPRand::ColorAV) * 256) * pcv.w();
    }
    d->startColor = {r, g, b, a};
 
    // Sprite sequence animation
    if (auto sequence = particle->m_spriteSequence) {
        if (sequence->duration() > 0) {
            float animationTimeMs = float(sequence->duration()) / 1000.0f;
            float animationTimeVarMs = float(sequence->durationVariation()) / 1000.0f;
            animationTimeVarMs = animationTimeVarMs - 2.0f * rand->get(particleIdIndex, QPRand::SpriteAnimationV) * animationTimeVarMs;
            // Sequence duration to be at least 1ms
            const float MIN_DURATION = 0.001f;
            d->animationTime = std::max(MIN_DURATION, animationTimeMs + animationTimeVarMs);
        } else {
            // Duration not set, so use the lifetime of the particle
            d->animationTime = d->lifetime;
        }
    }
    d->reversed = m_reversed;
}
 
int QQuick3DParticleEmitter::getEmitAmountFromDynamicBursts(int triggerType)
{
    int amount = 0;
    const int currentTime = m_system->time();
    const int prevTime = m_prevBurstTime;
    // First go through dynamic bursts and see if any of them tiggers
    for (auto *burst : std::as_const(m_emitBursts)) {
        auto *burstPtr = qobject_cast<QQuick3DParticleDynamicBurst *>(burst);
        if (!burstPtr)
            continue;
        if (!burstPtr->m_enabled)
            continue;
        // Trigering on trail emitter start / end
        const bool trailTriggering = triggerType && (burstPtr->m_triggerMode) == triggerType;
        // Triggering on time for the first time
        const bool timeTriggeringStart = !triggerType && currentTime >= burstPtr->m_time && prevTime <= burstPtr->m_time;
        if (trailTriggering || timeTriggeringStart) {
            int burstAmount = burstPtr->m_amount;
            if (burstPtr->m_amountVariation > 0) {
                auto rand = m_system->rand();
                int randAmount = 2 * rand->get() * burstPtr->m_amountVariation;
                burstAmount += burstPtr->m_amountVariation - randAmount;
            }
            if (burstAmount > 0) {
                if (timeTriggeringStart && burstPtr->m_duration > 0) {
                    // Burst with duration, so generate burst data
                    BurstEmitData emitData;
                    emitData.startTime = currentTime;
                    emitData.endTime = currentTime + burstPtr->m_duration;
                    emitData.emitAmount = burstAmount;
                    emitData.prevBurstTime = prevTime;
                    m_burstEmitData << emitData;
                } else {
                    // Directly trigger the amount
                    amount += burstAmount;
                }
            }
        }
    }
    // Then go through the triggered emit bursts list
    for (int burstIndex = 0; burstIndex < m_burstEmitData.size(); ++burstIndex) {
        auto &burstData = m_burstEmitData[burstIndex];
        const int amountLeft = burstData.emitAmount - burstData.emitCounter;
        if (currentTime >= burstData.endTime) {
            // Burst time has ended, emit all rest of the particles and remove the burst
            amount += amountLeft;
            m_burstEmitData.removeAt(burstIndex);
        } else {
            // Otherwise burst correct amount depending on burst duration
            const int durationTime = currentTime - burstData.prevBurstTime;
            const int burstDurationTime = burstData.endTime - burstData.startTime;
            int burstAmount = burstData.emitAmount * (float(durationTime) / float(burstDurationTime));
            burstAmount = std::min(amountLeft, burstAmount);
            if (burstAmount > 0) {
                amount += burstAmount;
                burstData.emitCounter += burstAmount;
                burstData.prevBurstTime = currentTime;
            }
        }
    }
    // Reset the prev burst time
    m_prevBurstTime = currentTime;
    return amount;
}
 
int QQuick3DParticleEmitter::getEmitAmount()
{
    if (!m_system)
        return 0;
 
    if (!m_enabled)
        return 0;
 
    if (m_emitRate <= 0.0f)
        return 0;
 
    float timeChange = m_system->currentTime() - m_prevEmitTime;
    float emitAmountF = timeChange / (1000.0f / m_emitRate);
    int emitAmount = floorf(emitAmountF);
    // Store the partly unemitted particles
    // When emitAmount = 0, we just let the timeChange grow.
    if (emitAmount > 0) {
        m_unemittedF += (emitAmountF - emitAmount);
        // When unemitted grow to a full particle, emit it
        // This way if emit rate is 140 emitAmounts can be e.g. 2,2,3,2,2,3 etc.
        if (m_unemittedF >= 1.0f) {
            emitAmount++;
            m_unemittedF--;
        }
    }
    return emitAmount;
}
 
void QQuick3DParticleEmitter::emitParticlesBurst(const QQuick3DParticleEmitBurstData &burst)
{
    if (!m_system)
        return;
 
    if (!m_enabled)
        return;
 
    if (!m_particle)
        return;
 
    QMatrix4x4 transform = calculateParticleTransform(parentNode(), m_systemSharedParent);
    QQuaternion rotation = calculateParticleRotation(parentNode(), m_systemSharedParent);
    QVector3D centerPos = position() + burst.position;
 
    int emitAmount = std::min(burst.amount, int(m_particle->maxAmount()));
    for (int i = 0; i < emitAmount; i++) {
        // Distribute evenly between time and time+duration.
        float startTime = (burst.time / 1000.0f) + (float(1 + i) / emitAmount) * ((burst.duration) / 1000.0f);
        emitParticle(m_particle, startTime, transform, rotation, centerPos);
    }
}
 
// Called to emit set of particles
void QQuick3DParticleEmitter::emitParticles()
{
    if (!m_system)
        return;
 
    if (!m_enabled)
        return;
 
    if (!m_particle)
        return;
 
    auto *mbp = qobject_cast<QQuick3DParticleModelBlendParticle *>(m_particle);
    if (mbp && mbp->activationNode() && mbp->emitMode() == QQuick3DParticleModelBlendParticle::Activation) {
        // The particles are emitted using the activationNode instead of regular emit
        emitActivationNodeParticles(mbp);
        return;
    }
 
    const int systemTime = m_system->currentTime();
 
    if (systemTime < m_prevEmitTime) {
        // If we are goint backwards, reset previous emit time to current time.
        m_prevEmitTime = systemTime;
    } else {
        // Keep previous emitting time within max the life span.
        // This way emitting is reasonable also with big time jumps.
        const int maxLifeSpan = m_lifeSpan + m_lifeSpanVariation;
        m_prevEmitTime = std::max(m_prevEmitTime, systemTime - maxLifeSpan);
    }
 
    // If bursts have changed, generate them first in the beginning
    if (!m_burstGenerated)
       generateEmitBursts();
 
    int emitAmount = getEmitAmount() + getEmitAmountFromDynamicBursts();
 
    // With lower emitRates, let timeChange grow until at least 1 particle is emitted
    if (emitAmount < 1)
        return;
 
    QMatrix4x4 transform = calculateParticleTransform(parentNode(), m_systemSharedParent);
    QQuaternion rotation = calculateParticleRotation(parentNode(), m_systemSharedParent);
    QVector3D centerPos = position();
 
    emitAmount = std::min(emitAmount, int(m_particle->maxAmount()));
    for (int i = 0; i < emitAmount; i++) {
        // Distribute evenly between previous and current time, important especially
        // when time has jumped a lot (like a starttime).
        float startTime = (m_prevEmitTime / 1000.0f) + (float(1+i) / emitAmount) * ((systemTime - m_prevEmitTime) / 1000.0f);
        emitParticle(m_particle, startTime, transform, rotation, centerPos);
    }
 
    m_prevEmitTime = systemTime;
}
 
void QQuick3DParticleEmitter::emitActivationNodeParticles(QQuick3DParticleModelBlendParticle *particle)
{
    QMatrix4x4 matrix = particle->activationNode()->sceneTransform();
    QMatrix4x4 actTransform = sceneTransform().inverted() * matrix;
    QVector3D front = actTransform.column(2).toVector3D();
    QVector3D pos = actTransform.column(3).toVector3D();
    float d = QVector3D::dotProduct(pos, front);
 
    const int systemTime = m_system->currentTime();
 
    // Keep previous emitting time within max the life span.
    // This way emitting is reasonable also with big time jumps.
    const int maxLifeSpan = m_lifeSpan + m_lifeSpanVariation;
    m_prevEmitTime = std::max(m_prevEmitTime, systemTime - maxLifeSpan);
 
    float startTime = systemTime / 1000.0f;
 
    QMatrix4x4 transform = calculateParticleTransform(parentNode(), m_systemSharedParent);
    QQuaternion rotation = calculateParticleRotation(parentNode(), m_systemSharedParent);
    QVector3D centerPos = position();
 
    for (int i = 0; i < particle->maxAmount(); i++) {
        if (particle->m_particleData[i].startTime >= 0)
            continue;
        const QVector3D pc = particle->particleCenter(i);
        if (QVector3D::dotProduct(front, pc) - d > 0.0f)
            emitParticle(particle, startTime, transform, rotation, centerPos, i);
    }
 
    m_prevEmitTime = systemTime;
}
 
void QQuick3DParticleEmitter::componentComplete()
{
    if (!m_system && qobject_cast<QQuick3DParticleSystem *>(parentItem()))
        setSystem(qobject_cast<QQuick3DParticleSystem *>(parentItem()));
 
    // When dynamically creating emitters, start from the current time.
    if (m_system)
        m_prevEmitTime = m_system->currentTime();
 
    QQuick3DNode::componentComplete();
}
 
// EmitBursts - list handling
 
/*!
    \qmlproperty List<EmitBurst3D> ParticleEmitter3D::emitBursts
 
    This property takes a list of \l EmitBurst3D elements, to declaratively define bursts.
    If the burst starting time, amount, and duration are known beforehand, it is better to
    use this property than e.g. calling \l burst() with a \l Timer.
 
    For example, to emit 100 particles at the beginning, and 50 particles at 2 seconds:
 
    \qml
    ParticleEmitter3D {
        emitBursts: [
            EmitBurst3D {
                time: 0
                amount: 100
            },
            EmitBurst3D {
                time: 2000
                amount: 50
            }
        ]
    }
    \endqml
 
    \sa burst()
*/
QQmlListProperty<QQuick3DParticleEmitBurst> QQuick3DParticleEmitter::emitBursts()
{
    return {this, this,
             &QQuick3DParticleEmitter::appendEmitBurst,
             &QQuick3DParticleEmitter::emitBurstCount,
             &QQuick3DParticleEmitter::emitBurst,
             &QQuick3DParticleEmitter::clearEmitBursts,
             &QQuick3DParticleEmitter::replaceEmitBurst,
             &QQuick3DParticleEmitter::removeLastEmitBurst};
}
 
void QQuick3DParticleEmitter::appendEmitBurst(QQuick3DParticleEmitBurst* n) {
    m_emitBursts.append(n);
}
 
qsizetype QQuick3DParticleEmitter::emitBurstCount() const
{
    return m_emitBursts.size();
}
 
QQuick3DParticleEmitBurst *QQuick3DParticleEmitter::emitBurst(qsizetype index) const
{
    return m_emitBursts.at(index);
}
 
void QQuick3DParticleEmitter::clearEmitBursts() {
    m_emitBursts.clear();
}
 
void QQuick3DParticleEmitter::replaceEmitBurst(qsizetype index, QQuick3DParticleEmitBurst *n)
{
    m_emitBursts[index] = n;
}
 
void QQuick3DParticleEmitter::removeLastEmitBurst()
{
    m_emitBursts.removeLast();
}
 
// EmitBursts - static
void QQuick3DParticleEmitter::appendEmitBurst(QQmlListProperty<QQuick3DParticleEmitBurst> *list, QQuick3DParticleEmitBurst *p) {
    reinterpret_cast< QQuick3DParticleEmitter *>(list->data)->appendEmitBurst(p);
}
 
void QQuick3DParticleEmitter::clearEmitBursts(QQmlListProperty<QQuick3DParticleEmitBurst> *list) {
    reinterpret_cast< QQuick3DParticleEmitter *>(list->data)->clearEmitBursts();
}
 
void QQuick3DParticleEmitter::replaceEmitBurst(QQmlListProperty<QQuick3DParticleEmitBurst> *list, qsizetype i, QQuick3DParticleEmitBurst *p)
{
    reinterpret_cast< QQuick3DParticleEmitter *>(list->data)->replaceEmitBurst(i, p);
}
 
void QQuick3DParticleEmitter::removeLastEmitBurst(QQmlListProperty<QQuick3DParticleEmitBurst> *list)
{
    reinterpret_cast< QQuick3DParticleEmitter *>(list->data)->removeLastEmitBurst();
}
 
QQuick3DParticleEmitBurst* QQuick3DParticleEmitter::emitBurst(QQmlListProperty<QQuick3DParticleEmitBurst> *list, qsizetype i) {
    return reinterpret_cast< QQuick3DParticleEmitter *>(list->data)->emitBurst(i);
}
 
qsizetype QQuick3DParticleEmitter::emitBurstCount(QQmlListProperty<QQuick3DParticleEmitBurst> *list) {
    return reinterpret_cast< QQuick3DParticleEmitter *>(list->data)->emitBurstCount();
}
 
QT_END_NAMESPACE