qquick3dparticlewander.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
 
#include <QtCore/qmath.h>
#include "qquick3dparticlewander_p.h"
#include "qquick3dparticlerandomizer_p.h"
#include "qquick3dparticleutils_p.h"
 
QT_BEGIN_NAMESPACE
 
QQuick3DParticleWander::QQuick3DParticleWander(QQuick3DNode *parent)
    : QQuick3DParticleAffector(parent)
{
}
 
const QVector3D &QQuick3DParticleWander::globalAmount() const
{
    return m_globalAmount;
}
 
const QVector3D &QQuick3DParticleWander::globalPace() const
{
    return m_globalPace;
}
 
const QVector3D &QQuick3DParticleWander::globalPaceStart() const
{
    return m_globalPaceStart;
}
 
const QVector3D &QQuick3DParticleWander::uniqueAmount() const
{
    return m_uniqueAmount;
}
 
const QVector3D &QQuick3DParticleWander::uniquePace() const
{
    return m_uniquePace;
}
 
float QQuick3DParticleWander::uniqueAmountVariation() const
{
    return m_uniqueAmountVariation;
}
 
float QQuick3DParticleWander::uniquePaceVariation() const
{
    return m_uniquePaceVariation;
}
 
int QQuick3DParticleWander::fadeInDuration() const
{
    return m_fadeInDuration;
}
 
int QQuick3DParticleWander::fadeOutDuration() const
{
    return m_fadeOutDuration;
}
 
void QQuick3DParticleWander::setGlobalAmount(const QVector3D &globalAmount)
{
    if (m_globalAmount == globalAmount)
        return;
 
    m_globalAmount = globalAmount;
    Q_EMIT globalAmountChanged();
    Q_EMIT update();
}
 
void QQuick3DParticleWander::setGlobalPace(const QVector3D &globalPace)
{
    if (m_globalPace == globalPace)
        return;
 
    m_globalPace = globalPace;
    Q_EMIT globalPaceChanged();
    Q_EMIT update();
}
 
void QQuick3DParticleWander::setGlobalPaceStart(const QVector3D &globalPaceStart)
{
    if (m_globalPaceStart == globalPaceStart)
        return;
 
    m_globalPaceStart = globalPaceStart;
    Q_EMIT globalPaceStartChanged();
    Q_EMIT update();
}
 
void QQuick3DParticleWander::setUniqueAmount(const QVector3D &uniqueAmount)
{
    if (m_uniqueAmount == uniqueAmount)
        return;
 
    m_uniqueAmount = uniqueAmount;
    Q_EMIT uniqueAmountChanged();
    Q_EMIT update();
}
 
void QQuick3DParticleWander::setUniquePace(const QVector3D &uniquePace)
{
    if (m_uniquePace == uniquePace)
        return;
 
    m_uniquePace = uniquePace;
    Q_EMIT uniquePaceChanged();
    Q_EMIT update();
}
 
void QQuick3DParticleWander::setUniqueAmountVariation(float uniqueAmountVariation)
{
    if (qFuzzyCompare(m_uniqueAmountVariation, uniqueAmountVariation))
        return;
 
    uniqueAmountVariation = std::max(0.0f, std::min(1.0f, uniqueAmountVariation));
    m_uniqueAmountVariation = uniqueAmountVariation;
    Q_EMIT uniqueAmountVariationChanged();
    Q_EMIT update();
}
 
void QQuick3DParticleWander::setUniquePaceVariation(float uniquePaceVariation)
{
    if (qFuzzyCompare(m_uniquePaceVariation, uniquePaceVariation))
        return;
 
    uniquePaceVariation = std::max(0.0f, std::min(1.0f, uniquePaceVariation));
    m_uniquePaceVariation = uniquePaceVariation;
    Q_EMIT uniquePaceVariationChanged();
    Q_EMIT update();
}
 
void QQuick3DParticleWander::setFadeInDuration(int fadeInDuration)
{
    if (m_fadeInDuration == fadeInDuration)
        return;
 
    m_fadeInDuration = std::max(0, fadeInDuration);
    Q_EMIT fadeInDurationChanged();
    Q_EMIT update();
}
 
void QQuick3DParticleWander::setFadeOutDuration(int fadeOutDuration)
{
    if (m_fadeOutDuration == fadeOutDuration)
        return;
 
    m_fadeOutDuration = std::max(0, fadeOutDuration);
    Q_EMIT fadeOutDurationChanged();
    Q_EMIT update();
}
 
void QQuick3DParticleWander::affectParticle(const QQuick3DParticleData &sd, QQuick3DParticleDataCurrent *d, float time)
{
    if (!system())
        return;
    auto rand = system()->rand();
 
    // Optionally smoothen the beginning & end of wander
    float smooth = 1.0f;
    if (m_fadeInDuration > 0) {
        smooth = time / (float(m_fadeInDuration) / 1000.0f);
        smooth = std::min(1.0f, smooth);
    }
    if (m_fadeOutDuration > 0) {
        float timeLeft = (sd.lifetime - time);
        float smoothOut = timeLeft / (float(m_fadeOutDuration) / 1000.0f);
        // When fading both in & out, select smaller (which is always max 1.0)
        smooth = std::min(smoothOut, smooth);
    }
 
    const float pi2 = float(M_PI * 2);
    // Global
    if (!qFuzzyIsNull(m_globalAmount.x()) && !qFuzzyIsNull(m_globalPace.x()))
        d->position.setX(d->position.x() + smooth * QPSIN(m_globalPaceStart.x() + time * pi2 * m_globalPace.x()) * m_globalAmount.x());
    if (!qFuzzyIsNull(m_globalAmount.y()) && !qFuzzyIsNull(m_globalPace.y()))
        d->position.setY(d->position.y() + smooth * QPSIN(m_globalPaceStart.y() + time * pi2 * m_globalPace.y()) * m_globalAmount.y());
    if (!qFuzzyIsNull(m_globalAmount.z()) && !qFuzzyIsNull(m_globalPace.z()))
        d->position.setZ(d->position.z() + smooth * QPSIN(m_globalPaceStart.z() + time * pi2 * m_globalPace.z()) * m_globalAmount.z());
 
    // Unique
    // Rather simple to only use a single sin operation per direction
    if (!qFuzzyIsNull(m_uniqueAmount.x()) && !qFuzzyIsNull(m_uniquePace.x())) {
        // Values between  1.0 +/- variation
        float paceVariation = 1.0f + m_uniquePaceVariation - 2.0f * rand->get(sd.index, QPRand::WanderXPV) * m_uniquePaceVariation;
        float amountVariation = 1.0f + m_uniqueAmountVariation - 2.0f * rand->get(sd.index, QPRand::WanderXAV) * m_uniqueAmountVariation;
        float startPace = rand->get(sd.index, QPRand::WanderXPS) * pi2;
        float pace = startPace + paceVariation * time * pi2 * m_uniquePace.x();
        float amount = amountVariation * m_uniqueAmount.x();
        d->position.setX(d->position.x() + smooth * QPSIN(pace) * amount);
    }
    if (!qFuzzyIsNull(m_uniqueAmount.y()) && !qFuzzyIsNull(m_uniquePace.y())) {
        // Values between  1.0 +/- variation
        float paceVariation = 1.0f + m_uniquePaceVariation - 2.0f * rand->get(sd.index, QPRand::WanderYPV) * m_uniquePaceVariation;
        float amountVariation = 1.0f + m_uniqueAmountVariation - 2.0f * rand->get(sd.index, QPRand::WanderYAV) * m_uniqueAmountVariation;
        float startPace = rand->get(sd.index, QPRand::WanderYPS) * pi2;
        float pace = startPace + paceVariation * time * pi2 * m_uniquePace.y();
        float amount = amountVariation * m_uniqueAmount.y();
        d->position.setY(d->position.y() + smooth * QPSIN(pace) * amount);
    }
    if (!qFuzzyIsNull(m_uniqueAmount.z()) && !qFuzzyIsNull(m_uniquePace.z())) {
        // Values between  1.0 +/- variation
        float paceVariation = 1.0f + m_uniquePaceVariation - 2.0f * rand->get(sd.index, QPRand::WanderZPV) * m_uniquePaceVariation;
        float amountVariation = 1.0f + m_uniqueAmountVariation - 2.0f * rand->get(sd.index, QPRand::WanderZAV) * m_uniqueAmountVariation;
        float startPace = rand->get(sd.index, QPRand::WanderZPS) * pi2;
        float pace = startPace + paceVariation * time * pi2 * m_uniquePace.z();
        float amount = amountVariation * m_uniqueAmount.z();
        d->position.setZ(d->position.z() + smooth * QPSIN(pace) * amount);
    }
}
 
QT_END_NAMESPACE