qquickparticleaffector.cpp

Go to the documentation of this file.

// 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 "qquickparticleaffector_p.h"
#include <QDebug>
#include <private/qqmlglobal_p.h>
QT_BEGIN_NAMESPACE
 
 
QQuickParticleAffector::QQuickParticleAffector(QQuickItem *parent) :
    QQuickItem(parent), m_needsReset(false), m_ignoresTime(false), m_onceOff(false), m_enabled(true)
    , m_system(nullptr), m_updateIntSet(false), m_shape(new QQuickParticleExtruder(this))
{
}
 
bool QQuickParticleAffector::isAffectedConnected()
{
    IS_SIGNAL_CONNECTED(this, QQuickParticleAffector, affected, (qreal,qreal));
}
 
 
void QQuickParticleAffector::componentComplete()
{
    if (!m_system && qobject_cast<QQuickParticleSystem*>(parentItem()))
        setSystem(qobject_cast<QQuickParticleSystem*>(parentItem()));
    QQuickItem::componentComplete();
}
 
bool QQuickParticleAffector::activeGroup(int g) {
    if (!m_system)
        return false;
 
    if (m_updateIntSet){ //This can occur before group ids are properly assigned, but that resets the flag
        m_groupIds.clear();
        foreach (const QString &p, m_groups)
            m_groupIds << m_system->groupIds[p];
        m_updateIntSet = false;
    }
    return m_groupIds.isEmpty() || m_groupIds.contains(g);
}
 
bool QQuickParticleAffector::shouldAffect(QQuickParticleData* d)
{
    if (!d)
        return false;
    if (!m_system)
        return false;
 
    if (activeGroup(d->groupId)){
        if ((m_onceOff && m_onceOffed.contains(qMakePair(d->groupId, d->index)))
                || !d->stillAlive(m_system))
            return false;
        //Need to have previous location for affected anyways
        if (width() == 0 || height() == 0
                || m_shape->contains(QRectF(m_offset.x(), m_offset.y(), width(), height()), QPointF(d->curX(m_system), d->curY(m_system)))){
            if (m_whenCollidingWith.isEmpty() || isColliding(d)){
                return true;
            }
        }
    }
    return false;
 
}
 
void QQuickParticleAffector::postAffect(QQuickParticleData* d)
{
    if (!m_system)
        return;
 
    m_system->needsReset << d;
    if (m_onceOff)
        m_onceOffed << qMakePair(d->groupId, d->index);
    if (isAffectedConnected())
        emit affected(d->curX(m_system), d->curY(m_system));
}
 
const qreal QQuickParticleAffector::simulationDelta = 0.020;
const qreal QQuickParticleAffector::simulationCutoff = 1.000;//If this goes above 1.0, then m_once behaviour needs special codepath
 
void QQuickParticleAffector::affectSystem(qreal dt)
{
    if (!m_enabled)
        return;
    if (!m_system)
        return;
 
    //If not reimplemented, calls affectParticle per particle
    //But only on particles in targeted system/area
    updateOffsets();//### Needed if an ancestor is transformed.
    if (m_onceOff)
        dt = 1.0;
    for (QQuickParticleGroupData* gd : std::as_const(m_system->groupData)) {
        if (activeGroup(gd->index)) {
            for (QQuickParticleData* d : std::as_const(gd->data)) {
                if (shouldAffect(d)) {
                    bool affected = false;
                    qreal myDt = dt;
                    if (!m_ignoresTime && myDt < simulationCutoff) {
                        int realTime = m_system->timeInt;
                        m_system->timeInt -= myDt * 1000.0;
                        while (myDt > simulationDelta) {
                            m_system->timeInt += simulationDelta * 1000.0;
                            if (d->alive(m_system))//Only affect during the parts it was alive for
                                affected = affectParticle(d, simulationDelta) || affected;
                            myDt -= simulationDelta;
                        }
                        m_system->timeInt = realTime;
                    }
                    if (myDt > 0.0)
                        affected = affectParticle(d, myDt) || affected;
                    if (affected)
                        postAffect(d);
                }
            }
        }
    }
}
 
bool QQuickParticleAffector::affectParticle(QQuickParticleData *, qreal )
{
    return true;
}
 
void QQuickParticleAffector::reset(QQuickParticleData* pd)
{//TODO: This, among other ones, should be restructured so they don't all need to remember to call the superclass
    if (m_onceOff)
        if (activeGroup(pd->groupId))
            m_onceOffed.remove(qMakePair(pd->groupId, pd->index));
}
 
void QQuickParticleAffector::updateOffsets()
{
    if (m_system)
        m_offset = m_system->mapFromItem(this, QPointF(0, 0));
}
 
bool QQuickParticleAffector::isColliding(QQuickParticleData *d) const
{
    if (!m_system)
        return false;
 
    qreal myCurX = d->curX(m_system);
    qreal myCurY = d->curY(m_system);
    qreal myCurSize = d->curSize(m_system) / 2;
    foreach (const QString &group, m_whenCollidingWith){
        foreach (QQuickParticleData* other, m_system->groupData[m_system->groupIds[group]]->data){
            if (!other->stillAlive(m_system))
                continue;
            qreal otherCurX = other->curX(m_system);
            qreal otherCurY = other->curY(m_system);
            qreal otherCurSize = other->curSize(m_system) / 2;
            if ((myCurX + myCurSize > otherCurX - otherCurSize
                 && myCurX - myCurSize < otherCurX + otherCurSize)
                 && (myCurY + myCurSize > otherCurY - otherCurSize
                     && myCurY - myCurSize < otherCurY + otherCurSize))
                return true;
        }
    }
    return false;
}
 
QT_END_NAMESPACE
 
#include "moc_qquickparticleaffector_p.cpp"