qquickcustomaffector.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 "qquickcustomaffector_p.h"
#include <private/qqmlengine_p.h>
#include <private/qqmlglobal_p.h>
#include <private/qjsvalue_p.h>
#include <QQmlEngine>
#include <QDebug>
QT_BEGIN_NAMESPACE
 
//TODO: Move docs (and inheritence) to real base when docs can propagate. Currently this pretends to be the base class!
QQuickCustomAffector::QQuickCustomAffector(QQuickItem *parent) :
    QQuickParticleAffector(parent)
    , m_position(&m_nullVector)
    , m_velocity(&m_nullVector)
    , m_acceleration(&m_nullVector)
    , m_relative(true)
{
}
 
bool QQuickCustomAffector::isAffectConnected()
{
    IS_SIGNAL_CONNECTED(this, QQuickCustomAffector, affectParticles, (const QJSValue &, qreal));
}
 
void QQuickCustomAffector::affectSystem(qreal dt)
{
    //Acts a bit differently, just emits affected for everyone it might affect, when the only thing is connecting to affected(x,y)
    bool justAffected = (m_acceleration == &m_nullVector
        && m_velocity == &m_nullVector
        && m_position == &m_nullVector
        && isAffectedConnected());
    if (!isAffectConnected() && !justAffected) {
        QQuickParticleAffector::affectSystem(dt);
        return;
    }
    if (!m_enabled)
        return;
    updateOffsets();
 
    QList<QQuickParticleData*> toAffect;
    for (const QQuickParticleGroupData *gd : std::as_const(m_system->groupData)) {
        if (activeGroup(gd->index)) {
            for (QQuickParticleData *d : gd->data) {
                if (shouldAffect(d)) {
                    toAffect << d;
                }
            }
        }
    }
 
    if (toAffect.isEmpty())
        return;
 
    if (justAffected) {
        for (const QQuickParticleData *d : std::as_const(toAffect)) {//Not postAffect to avoid saying the particle changed
            if (m_onceOff)
                m_onceOffed << qMakePair(d->groupId, d->index);
            emit affected(d->curX(m_system), d->curY(m_system));
        }
        return;
    }
 
    if (m_onceOff)
        dt = 1.0;
 
    QQmlEngine *qmlEngine = ::qmlEngine(this);
    QV4::ExecutionEngine *v4 = qmlEngine->handle();
 
    QV4::Scope scope(v4);
    QV4::ScopedArrayObject array(scope, v4->newArrayObject(toAffect.size()));
    QV4::ScopedValue v(scope);
    for (int i=0; i<toAffect.size(); i++)
        array->put(i, (v = toAffect[i]->v4Value(m_system)));
 
    const auto doAffect = [&](qreal dt) {
        affectProperties(toAffect, dt);
        QJSValue particles;
        QJSValuePrivate::setValue(&particles, array);
        emit affectParticles(particles, dt);
    };
 
    if (dt >= simulationCutoff || dt <= simulationDelta) {
        doAffect(dt);
    } else {
        int realTime = m_system->timeInt;
        m_system->timeInt -= dt * 1000.0;
        while (dt > simulationDelta) {
            m_system->timeInt += simulationDelta * 1000.0;
            dt -= simulationDelta;
            doAffect(simulationDelta);
        }
        m_system->timeInt = realTime;
        if (dt > 0.0)
            doAffect(dt);
    }
 
    for (QQuickParticleData *d : std::as_const(toAffect))
        if (d->update == 1.0)
            postAffect(d);
}
 
bool QQuickCustomAffector::affectParticle(QQuickParticleData *d, qreal dt)
{
    //This does the property based affecting, called by superclass if signal isn't hooked up.
    bool changed = false;
    QPointF curPos(d->curX(m_system), d->curY(m_system));
 
    if (m_acceleration != &m_nullVector){
        QPointF pos = m_acceleration->sample(curPos);
        QPointF curAcc = QPointF(d->curAX(), d->curAY());
        if (m_relative) {
            pos *= dt;
            pos += curAcc;
        }
        if (pos != curAcc) {
            d->setInstantaneousAX(pos.x(), m_system);
            d->setInstantaneousAY(pos.y(), m_system);
            changed = true;
        }
    }
 
    if (m_velocity != &m_nullVector){
        QPointF pos = m_velocity->sample(curPos);
        QPointF curVel = QPointF(d->curVX(m_system), d->curVY(m_system));
        if (m_relative) {
            pos *= dt;
            pos += curVel;
        }
        if (pos != curVel) {
            d->setInstantaneousVX(pos.x(), m_system);
            d->setInstantaneousVY(pos.y(), m_system);
            changed = true;
        }
    }
 
    if (m_position != &m_nullVector){
        QPointF pos = m_position->sample(curPos);
        if (m_relative) {
            pos *= dt;
            pos += curPos;
        }
        if (pos != curPos) {
            d->setInstantaneousX(pos.x(), m_system);
            d->setInstantaneousY(pos.y(), m_system);
            changed = true;
        }
    }
 
    return changed;
}
 
void QQuickCustomAffector::affectProperties(const QList<QQuickParticleData*> &particles, qreal dt)
{
    for (QQuickParticleData *d : particles)
        if ( affectParticle(d, dt) )
            d->update = 1.0;
}
 
QT_END_NAMESPACE
 
#include "moc_qquickcustomaffector_p.cpp"