Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#ifndef PARTICLEEMITTER_H
#define PARTICLEEMITTER_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtQuick/QQuickItem>
#include <QDebug>
#include "qquickparticlesystem_p.h"
#include "qquickparticleextruder_p.h"
#include "qquickdirection_p.h"
#include <QList>
#include <QPointF>
#include <utility>
QT_BEGIN_NAMESPACE
class Q_QUICKPARTICLES_EXPORT QQuickParticleEmitter : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QQuickParticleSystem* system READ system WRITE setSystem NOTIFY systemChanged)
Q_PROPERTY(QString group READ group WRITE setGroup NOTIFY groupChanged)
Q_PROPERTY(QQuickParticleExtruder* shape READ extruder WRITE setExtruder NOTIFY extruderChanged)
Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged OVERRIDE)
Q_PROPERTY(int startTime READ startTime WRITE setStartTime NOTIFY startTimeChanged)
Q_PROPERTY(qreal emitRate READ particlesPerSecond WRITE setParticlesPerSecond NOTIFY particlesPerSecondChanged)
Q_PROPERTY(int lifeSpan READ particleDuration WRITE setParticleDuration NOTIFY particleDurationChanged)
Q_PROPERTY(int lifeSpanVariation READ particleDurationVariation WRITE setParticleDurationVariation NOTIFY particleDurationVariationChanged)
Q_PROPERTY(int maximumEmitted READ maxParticleCount WRITE setMaxParticleCount NOTIFY maximumEmittedChanged)
Q_PROPERTY(qreal size READ particleSize WRITE setParticleSize NOTIFY particleSizeChanged)
Q_PROPERTY(qreal endSize READ particleEndSize WRITE setParticleEndSize NOTIFY particleEndSizeChanged)
Q_PROPERTY(qreal sizeVariation READ particleSizeVariation WRITE setParticleSizeVariation NOTIFY particleSizeVariationChanged)
Q_PROPERTY(QQuickDirection *velocity READ velocity WRITE setVelocity NOTIFY velocityChanged)
Q_PROPERTY(QQuickDirection *acceleration READ acceleration WRITE setAcceleration NOTIFY accelerationChanged)
Q_PROPERTY(qreal velocityFromMovement READ velocityFromMovement WRITE setVelocityFromMovement NOTIFY velocityFromMovementChanged)
QML_NAMED_ELEMENT(Emitter)
QML_ADDED_IN_VERSION(2, 0)
public:
explicit QQuickParticleEmitter(QQuickItem *parent = nullptr);
virtual ~QQuickParticleEmitter();
virtual void emitWindow(int timeStamp);
enum Lifetime {
InfiniteLife = QQuickParticleSystem::maxLife
};
Q_ENUM(Lifetime)
bool enabled() const
{
return m_enabled;
}
qreal particlesPerSecond() const
{
return m_particlesPerSecond;
}
int particleDuration() const
{
return m_particleDuration;
}
QQuickParticleSystem* system() const
{
return m_system;
}
QString group() const
{
return m_group;
}
QQuickParticleGroupData::ID groupId() const
{
if (m_groupIdNeedRecalculation)
reclaculateGroupId();
return m_groupId;
}
int particleDurationVariation() const
{
return m_particleDurationVariation;
}
qreal velocityFromMovement() const { return m_velocity_from_movement; }
void setVelocityFromMovement(qreal s);
void componentComplete() override;
Q_SIGNALS:
void emitParticles(const QList<QQuickV4ParticleData> &particles);
void particlesPerSecondChanged(qreal);
void particleDurationChanged(int);
void enabledChanged(bool);
void systemChanged(QQuickParticleSystem* arg);
void groupChanged(const QString &arg);
void particleDurationVariationChanged(int arg);
void extruderChanged(QQuickParticleExtruder* arg);
void particleSizeChanged(qreal arg);
void particleEndSizeChanged(qreal arg);
void particleSizeVariationChanged(qreal arg);
void velocityChanged(QQuickDirection * arg);
void accelerationChanged(QQuickDirection * arg);
void maximumEmittedChanged(int arg);
void particleCountChanged();
void velocityFromMovementChanged();
void startTimeChanged(int arg);
public Q_SLOTS:
void pulse(int milliseconds);
void burst(int num);
void burst(int num, qreal x, qreal y);
void setEnabled(bool arg);
void setParticlesPerSecond(qreal arg)
{
if (m_particlesPerSecond != arg) {
m_particlesPerSecond = arg;
callSystemEmittersChanged();
Q_EMIT particlesPerSecondChanged(arg);
}
}
void setParticleDuration(int arg)
{
if (m_particleDuration != arg) {
m_particleDuration = arg;
callSystemEmittersChanged();
Q_EMIT particleDurationChanged(arg);
}
}
void setSystem(QQuickParticleSystem* arg)
{
if (arg == m_system)
return;
if (m_system)
m_system->unregisterParticleEmitter(this);
m_system = arg;
m_groupIdNeedRecalculation = true;
if (m_system) {
m_system->registerParticleEmitter(this);
if (isComponentComplete())
m_system->finishRegisteringParticleEmitter(this);
}
Q_EMIT systemChanged(arg);
}
void setGroup(const QString &arg)
{
if (m_group != arg) {
m_group = arg;
m_groupIdNeedRecalculation = true;
callSystemEmittersChanged();
Q_EMIT groupChanged(arg);
}
}
void setParticleDurationVariation(int arg)
{
if (m_particleDurationVariation != arg) {
m_particleDurationVariation = arg;
Q_EMIT particleDurationVariationChanged(arg);
}
}
void setExtruder(QQuickParticleExtruder* arg)
{
if (m_extruder != arg) {
m_extruder = arg;
Q_EMIT extruderChanged(arg);
}
}
void setParticleSize(qreal arg)
{
if (m_particleSize != arg) {
m_particleSize = arg;
Q_EMIT particleSizeChanged(arg);
}
}
void setParticleEndSize(qreal arg)
{
if (m_particleEndSize != arg) {
m_particleEndSize = arg;
Q_EMIT particleEndSizeChanged(arg);
}
}
void setParticleSizeVariation(qreal arg)
{
if (m_particleSizeVariation != arg) {
m_particleSizeVariation = arg;
Q_EMIT particleSizeVariationChanged(arg);
}
}
void setVelocity(QQuickDirection * arg)
{
if (m_velocity != arg) {
m_velocity = arg;
Q_EMIT velocityChanged(arg);
}
}
void setAcceleration(QQuickDirection * arg)
{
if (m_acceleration != arg) {
m_acceleration = arg;
Q_EMIT accelerationChanged(arg);
}
}
void setMaxParticleCount(int arg);
void setStartTime(int arg)
{
if (m_startTime != arg) {
m_startTime = arg;
Q_EMIT startTimeChanged(arg);
}
}
virtual void reset();
public:
int particleCount() const
{
if (m_maxParticleCount >= 0)
return m_maxParticleCount;
return m_particlesPerSecond*((m_particleDuration+m_particleDurationVariation)/1000.0);
}
QQuickParticleExtruder* extruder() const
{
return m_extruder;
}
qreal particleSize() const
{
return m_particleSize;
}
qreal particleEndSize() const
{
return m_particleEndSize;
}
qreal particleSizeVariation() const
{
return m_particleSizeVariation;
}
QQuickDirection * velocity() const
{
return m_velocity;
}
QQuickDirection * acceleration() const
{
return m_acceleration;
}
int maxParticleCount() const
{
return m_maxParticleCount;
}
int startTime() const
{
return m_startTime;
}
void reclaculateGroupId() const;
protected:
qreal m_particlesPerSecond;
int m_particleDuration;
int m_particleDurationVariation;
bool m_enabled;
QQuickParticleSystem* m_system;
QQuickParticleExtruder* m_extruder;
QQuickParticleExtruder* m_defaultExtruder;
QQuickParticleExtruder* effectiveExtruder();
QQuickDirection * m_velocity;
QQuickDirection * m_acceleration;
qreal m_particleSize;
qreal m_particleEndSize;
qreal m_particleSizeVariation;
int m_startTime;
bool m_overwrite;
int m_pulseLeft;
QList<std::pair<int, QPointF > > m_burstQueue;
int m_maxParticleCount;
//Used in default implementation, but might be useful
qreal m_velocity_from_movement;
int m_emitCap;
bool m_reset_last;
qreal m_last_timestamp;
qreal m_last_emission;
QPointF m_last_emitter;
QPointF m_last_last_emitter;
bool isEmitConnected();
private: // data
void callSystemEmittersChanged();
QString m_group;
mutable bool m_groupIdNeedRecalculation;
mutable QQuickParticleGroupData::ID m_groupId;
QQuickDirection m_nullVector;
};
QT_END_NAMESPACE
#endif // PARTICLEEMITTER_H