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
#include <QtCore/qtconfigmacros.h>
#undef QT_NO_FOREACH // this file contains unported legacy Q_FOREACH uses
#include "qquickitemparticle_p.h"
#include "qquickparticleemitter_p.h"
#include <QtQuick/qsgnode.h>
#include <QTimer>
#include <QQmlComponent>
#include <QDebug>
QT_BEGIN_NAMESPACE
/*!
\qmltype ItemParticle
\inqmlmodule QtQuick.Particles
\inherits ParticlePainter
\brief For specifying a delegate to paint particles.
\ingroup qtquick-particles
*/
/*!
\qmlmethod void QtQuick.Particles::ItemParticle::freeze(Item item)
Suspends the flow of time for the logical particle which \a item represents,
allowing you to control its movement.
*/
/*!
\qmlmethod void QtQuick.Particles::ItemParticle::unfreeze(Item item)
Restarts the flow of time for the logical particle which \a item represents,
allowing it to be moved by the particle system again.
*/
/*!
\qmlmethod void QtQuick.Particles::ItemParticle::take(Item item, bool prioritize)
Asks the ItemParticle to take over control of \a item positioning temporarily.
It will follow the movement of a logical particle when one is available.
By default items form a queue when waiting for a logical particle, but if
\a prioritize is \c true, then it will go immediately to the head of the
queue.
ItemParticle does not take ownership of the item, and will relinquish
control when the logical particle expires. Commonly at this point you will
want to put it back in the queue, you can do this with the below line in
the delegate definition:
\code
ItemParticle.onDetached: itemParticleInstance.take(delegateRootItem);
\endcode
or delete it, such as with the below line in the delegate definition:
\code
ItemParticle.onDetached: delegateRootItem.destroy();
\endcode
*/
/*!
\qmlmethod void QtQuick.Particles::ItemParticle::give(Item item)
Orders the ItemParticle to give you control of the \a item. It will cease
controlling it and the item will lose its association to the logical
particle.
*/
/*!
\qmlproperty bool QtQuick.Particles::ItemParticle::fade
If true, the item will automatically be faded in and out
at the ends of its lifetime. If false, you will have to
implement any entry effect yourself.
Default is true.
*/
/*!
\qmlproperty Component QtQuick.Particles::ItemParticle::delegate
An instance of the delegate will be created for every logical particle, and
moved along with it. As an alternative to using delegate, you can create
Item instances yourself and hand them to the ItemParticle to move using the
\l take method.
Any delegate instances created by ItemParticle will be destroyed when
the logical particle expires.
*/
QQuickItemParticle::QQuickItemParticle(QQuickItem *parent) :
QQuickParticlePainter(parent), m_fade(true), m_lastT(0), m_activeCount(0), m_delegate(nullptr)
{
setFlag(QQuickItem::ItemHasContents);
clock = new Clock(this);
connect(this, &QQuickItemParticle::systemChanged, this, &QQuickItemParticle::reconnectSystem);
connect(this, &QQuickItemParticle::parentChanged, this, &QQuickItemParticle::reconnectParent);
connect(this, &QQuickItemParticle::enabledChanged, this, &QQuickItemParticle::updateClock);
reconnectSystem(m_system);
reconnectParent(parent);
}
QQuickItemParticle::~QQuickItemParticle()
{
delete clock;
qDeleteAll(m_managed);
}
void QQuickItemParticle::freeze(QQuickItem* item)
{
m_stasis << item;
}
void QQuickItemParticle::unfreeze(QQuickItem* item)
{
m_stasis.remove(item);
}
void QQuickItemParticle::take(QQuickItem *item, bool prioritize)
{
if (prioritize)
m_pendingItems.push_front(item);
else
m_pendingItems.push_back(item);
}
void QQuickItemParticle::give(QQuickItem *item)
{
for (auto groupId : groupIds()) {
for (QQuickParticleData* data : std::as_const(m_system->groupData[groupId]->data)) {
if (data->delegate == item){
m_deletables << item;
data->delegate = nullptr;
m_system->groupData[groupId]->kill(data);
return;
}
}
}
}
void QQuickItemParticle::initialize(int gIdx, int pIdx)
{
Q_UNUSED(gIdx);
Q_UNUSED(pIdx);
}
void QQuickItemParticle::commit(int, int)
{
}
void QQuickItemParticle::processDeletables()
{
foreach (QQuickItem* item, m_deletables){
if (m_fade)
item->setOpacity(0.);
item->setVisible(false);
QQuickItemParticleAttached* mpa;
if ((mpa = qobject_cast<QQuickItemParticleAttached*>(qmlAttachedPropertiesObject<QQuickItemParticle>(item)))) {
if (mpa->m_parentItem != nullptr)
item->setParentItem(mpa->m_parentItem);
mpa->detach();
}
int idx = -1;
if ((idx = m_managed.indexOf(item)) != -1) {
m_managed.takeAt(idx);
delete item;
}
m_activeCount--;
}
m_deletables.clear();
}
void QQuickItemParticle::tick(int time)
{
Q_UNUSED(time);//only needed because QTickAnimationProxy expects one
processDeletables();
for (auto groupId : groupIds()) {
for (QQuickParticleData* d : std::as_const(m_system->groupData[groupId]->data)) {
if (!d->delegate && d->t != -1 && d->stillAlive(m_system)) {
QQuickItem* parentItem = nullptr;
if (!m_pendingItems.isEmpty()){
QQuickItem *item = m_pendingItems.front();
m_pendingItems.pop_front();
parentItem = item->parentItem();
d->delegate = item;
}else if (m_delegate){
d->delegate = qobject_cast<QQuickItem*>(m_delegate->create(qmlContext(this)));
if (d->delegate)
m_managed << d->delegate;
}
if (d && d->delegate){//###Data can be zero if creating an item leads to a reset - this screws things up.
d->delegate->setX(d->curX(m_system) - d->delegate->width() / 2); //TODO: adjust for system?
d->delegate->setY(d->curY(m_system) - d->delegate->height() / 2);
QQuickItemParticleAttached* mpa = qobject_cast<QQuickItemParticleAttached*>(qmlAttachedPropertiesObject<QQuickItemParticle>(d->delegate));
if (mpa){
mpa->m_parentItem = parentItem;
mpa->m_mp = this;
mpa->attach();
}
d->delegate->setParentItem(this);
if (m_fade)
d->delegate->setOpacity(0.);
d->delegate->setVisible(false);//Will be set to true when we prepare the next frame
m_activeCount++;
}
}
}
}
}
void QQuickItemParticle::reset()
{
QQuickParticlePainter::reset();
// delete all managed items which had their logical particles cleared
// but leave it alone if the logical particle is maintained
QSet<QQuickItem*> lost = QSet<QQuickItem*>(m_managed.cbegin(), m_managed.cend());
for (auto groupId : groupIds()) {
for (QQuickParticleData* d : std::as_const(m_system->groupData[groupId]->data)) {
lost.remove(d->delegate);
}
}
m_deletables.unite(lost);
//TODO: This doesn't yet handle calling detach on taken particles in the system reset case
processDeletables();
}
QSGNode* QQuickItemParticle::updatePaintNode(QSGNode* n, UpdatePaintNodeData* d)
{
//Dummy update just to get painting tick
if (m_pleaseReset)
m_pleaseReset = false;
if (clockShouldUpdate()) {
prepareNextFrame();
update(); //Get called again
}
if (n)
n->markDirty(QSGNode::DirtyMaterial);
return QQuickItem::updatePaintNode(n,d);
}
void QQuickItemParticle::prepareNextFrame()
{
if (!m_system)
return;
qint64 timeStamp = m_system->systemSync(this);
qreal curT = timeStamp/1000.0;
qreal dt = curT - m_lastT;
m_lastT = curT;
if (!m_activeCount)
return;
//TODO: Size, better fade?
for (auto groupId : groupIds()) {
for (QQuickParticleData* data : std::as_const(m_system->groupData[groupId]->data)) {
QQuickItem* item = data->delegate;
if (!item)
continue;
float t = ((timeStamp / 1000.0f) - data->t) / data->lifeSpan;
if (m_stasis.contains(item)) {
data->t += dt;//Stasis effect
continue;
}
if (t >= 1.0f){//Usually happens from load
m_deletables << item;
data->delegate = nullptr;
}else{//Fade
data->delegate->setVisible(true);
if (m_fade){
float o = 1.f;
if (t <0.2f)
o = t * 5;
if (t > 0.8f)
o = (1-t)*5;
item->setOpacity(o);
}
}
item->setX(data->curX(m_system) - item->width() / 2 - m_systemOffset.x());
item->setY(data->curY(m_system) - item->height() / 2 - m_systemOffset.y());
}
}
}
QQuickItemParticleAttached *QQuickItemParticle::qmlAttachedProperties(QObject *object)
{
return new QQuickItemParticleAttached(object);
}
bool QQuickItemParticle::clockShouldUpdate() const
{
// Determine if the QQuickItemParticle clock should stop by looking at the system running
// state and any parent Emitter enabled state. Note that this enabled state is the overridden
// QQuickParticleEmitter::enabled, and not the unrelated QQuickItem::enabled (which controls
// if the item reacts to input events).
QQuickParticleEmitter *parentEmitter = qobject_cast<QQuickParticleEmitter *>(parent());
bool parentEmitterDisabled = parentEmitter && !parentEmitter->isEnabled();
bool systemRunning = m_system && (m_system->isRunning() || m_system->isPaused());
return systemRunning && !parentEmitterDisabled;
}
void QQuickItemParticle::reconnectParent(QQuickItem *parentItem)
{
updateClock();
disconnect(m_parentEnabledStateConnection);
if (parentItem) {
m_parentEnabledStateConnection = connect(parentItem, &QQuickParticleSystem::enabledChanged,
this, &QQuickItemParticle::updateClock);
}
}
void QQuickItemParticle::reconnectSystem(QQuickParticleSystem *system)
{
updateClock();
disconnect(m_systemRunStateConnection);
disconnect(m_systemPauseStateConnection);
disconnect(m_systemEnabledStateConnection);
if (system) {
m_systemRunStateConnection = connect(m_system, &QQuickParticleSystem::runningChanged, this, [this](){
QQuickItemParticle::updateClock();
});
m_systemPauseStateConnection = connect(m_system, &QQuickParticleSystem::pausedChanged, this, [this](){
QQuickItemParticle::updateClock();
});
m_systemEnabledStateConnection = connect(m_system, &QQuickParticleSystem::enabledChanged, this,
&QQuickItemParticle::updateClock);
}
}
void QQuickItemParticle::updateClock()
{
if (clockShouldUpdate()) {
if (!clock->isRunning())
clock->start();
} else {
if (clock->isRunning())
clock->pause();
}
}
QT_END_NAMESPACE
#include "moc_qquickitemparticle_p.cpp"