/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtDeclarative module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qdeclarativeparticles_p.h"

#include <qdeclarativeinfo.h>

#include <private/qdeclarativeitem_p.h>

#include <private/qdeclarativepixmapcache_p.h>

#include <QtCore/QAbstractAnimation>

#include <QPainter>

#include <QtGui/qdrawutil.h>

#include <QVarLengthArray>

#include <stdlib.h>

#include <math.h>

#ifndef M_PI

#define M_PI 3.14159265358979323846

#define M_PI_2 (M_PI / 2.)

#endif

#ifndef INT_MAX

#define INT_MAX 2147483647

#endif

QT_BEGIN_NAMESPACE

#define PI_SQR 9.8696044

// parabolic approximation

inline qreal fastSin(qreal theta)

{

    const qreal b = 4 / M_PI;

    const qreal c = -4 / PI_SQR;

    qreal y = b * theta + c * theta * qAbs(theta);

    return y;

}

inline qreal fastCos(qreal theta)

{

    theta += M_PI_2;

    if (theta > M_PI)

        theta -= 2 * M_PI;

    return fastSin(theta);

}

class QDeclarativeParticle

{

public:

    QDeclarativeParticle(int time) : lifeSpan(1000), fadeOutAge(800)

        , opacity(0), birthTime(time), x_velocity(0), y_velocity(0)

        , state(FadeIn), data(0)

    {

    }

    int lifeSpan;

    int fadeOutAge;

    qreal x;

    qreal y;

    qreal opacity;

    int birthTime;

    qreal x_velocity;

    qreal y_velocity;

    enum State { FadeIn, Solid, FadeOut };

    State state;

    void *data;

};

//---------------------------------------------------------------------------

/*!

    \class QDeclarativeParticleMotion

    \ingroup group_effects

    \brief The QDeclarativeParticleMotion class is the base class for particle motion.

    \internal

    This class causes the particles to remain static.

*/

/*!

    Constructs a QDeclarativeParticleMotion with parent object \a parent.

*/

QDeclarativeParticleMotion::QDeclarativeParticleMotion(QObject *parent) :

    QObject(parent)

{

}

/*!

    Move the \a particle to its new position.  \a interval is the number of

    milliseconds elapsed since it was last moved.

*/

void QDeclarativeParticleMotion::advance(QDeclarativeParticle &particle, int interval)

{

    Q_UNUSED(particle);

    Q_UNUSED(interval);

}

/*!

    The \a particle has just been created.  Some motion strategies require

    additional state information.  This can be allocated by this function.

*/

void QDeclarativeParticleMotion::created(QDeclarativeParticle &particle)

{

    Q_UNUSED(particle);

}

/*!

    The \a particle is about to be destroyed.  Any additional memory

    that has been allocated for the particle should be freed.

*/

void QDeclarativeParticleMotion::destroy(QDeclarativeParticle &particle)

{

    Q_UNUSED(particle);

}

/*!

    \qmlclass ParticleMotionLinear QDeclarativeParticleMotionLinear

    \since 4.7

    \brief The ParticleMotionLinear object moves particles linearly.

    \sa Particles

    This is the default motion, and moves the particles according to the

    properties specified in the Particles element.

    It has no further properties.

*/

void QDeclarativeParticleMotionLinear::advance(QDeclarativeParticle &p, int interval)

{

    p.x += interval * p.x_velocity;

    p.y += interval * p.y_velocity;

}

/*!

    \qmlclass ParticleMotionGravity QDeclarativeParticleMotionGravity

    \since 4.7

    \brief The ParticleMotionGravity object moves particles towards a point.

    This motion attracts the particles to the specified point with the specified acceleration.

    To mimic earth gravity, set yattractor to -6360000 and acceleration to 9.8.

    The defaults are all 0, not earth gravity, and so no motion will occur without setting

    at least the acceleration property.

    \sa Particles

*/

/*!

    \qmlproperty real ParticleMotionGravity::xattractor

    \qmlproperty real ParticleMotionGravity::yattractor

    These properties hold the x and y coordinates of the point attracting the particles.

*/

/*!

    \qmlproperty real ParticleMotionGravity::acceleration

    This property holds the acceleration to apply to the particles.

*/

/*!

    \property QDeclarativeParticleMotionGravity::xattractor

    \brief the x coordinate of the point attracting the particles.

*/

/*!

    \property QDeclarativeParticleMotionGravity::yattractor

    \brief the y coordinate of the point attracting the particles.

*/

/*!

    \property QDeclarativeParticleMotionGravity::acceleration

    \brief the acceleration to apply to the particles.

*/

void QDeclarativeParticleMotionGravity::setXAttractor(qreal x)

{

    if (qFuzzyCompare(x, _xAttr))

        return;

    _xAttr = x;

    emit xattractorChanged();

}

void QDeclarativeParticleMotionGravity::setYAttractor(qreal y)

{

    if (qFuzzyCompare(y, _yAttr))

        return;

    _yAttr = y;

    emit yattractorChanged();

}

void QDeclarativeParticleMotionGravity::setAcceleration(qreal accel)

{

    qreal scaledAccel = accel/1000000.0;

    if (qFuzzyCompare(scaledAccel, _accel))

        return;

    _accel = scaledAccel;

    emit accelerationChanged();

}

void QDeclarativeParticleMotionGravity::advance(QDeclarativeParticle &p, int interval)

{

    qreal xdiff = _xAttr - p.x;

    qreal ydiff = _yAttr - p.y;

    qreal absXdiff = qAbs(xdiff);

    qreal absYdiff = qAbs(ydiff);

    qreal xcomp = xdiff / (absXdiff + absYdiff);

    qreal ycomp = ydiff / (absXdiff + absYdiff);

    p.x_velocity += xcomp * _accel * interval;

    p.y_velocity += ycomp * _accel * interval;

    p.x += interval * p.x_velocity;

    p.y += interval * p.y_velocity;

}

/*!

    \qmlclass ParticleMotionWander QDeclarativeParticleMotionWander

    \since 4.7

    \brief The ParticleMotionWander object moves particles in a somewhat random fashion.

    The particles will continue roughly in the original direction, however will randomly

    drift to each side.

    The code below produces an effect similar to falling snow.

    \qml

Rectangle {

    width: 240

    height: 320

    color: "black"

    Particles {

        y: 0

        width: parent.width

        height: 30

        source: "star.png"

        lifeSpan: 5000

        count: 50

        angle: 70

        angleDeviation: 36

        velocity: 30

        velocityDeviation: 10

        ParticleMotionWander {

            xvariance: 30

            pace: 100

        }

    }

}

    \endqml

    \sa Particles

*/

/*!

    \qmlproperty real ParticleMotionWander::xvariance

    \qmlproperty real ParticleMotionWander::yvariance

    These properties set the amount to wander in the x and y directions.

*/

/*!

    \qmlproperty real ParticleMotionWander::pace

    This property holds how quickly the paricles will move from side to side.

*/

void QDeclarativeParticleMotionWander::advance(QDeclarativeParticle &p, int interval)

{

    if (!particles)

        particles = qobject_cast<QDeclarativeParticles*>(parent());

    if (particles) {

        Data *d = (Data*)p.data;

        if (_xvariance != 0.) {

            qreal xdiff = p.x_velocity - d->x_targetV;

            if ((xdiff > d->x_peak && d->x_var > 0.0) || (xdiff < -d->x_peak && d->x_var < 0.0)) {

                d->x_var = -d->x_var;

                d->x_peak = _xvariance + _xvariance * qreal(qrand()) / RAND_MAX;

            }

            p.x_velocity += d->x_var * interval;

        }

        p.x += interval * p.x_velocity;

        if (_yvariance != 0.) {

            qreal ydiff = p.y_velocity - d->y_targetV;

            if ((ydiff > d->y_peak && d->y_var > 0.0) || (ydiff < -d->y_peak && d->y_var < 0.0)) {

                d->y_var = -d->y_var;

                d->y_peak = _yvariance + _yvariance * qreal(qrand()) / RAND_MAX;

            }

            p.y_velocity += d->y_var * interval;

        }

        p.y += interval * p.y_velocity;

    }

}

void QDeclarativeParticleMotionWander::created(QDeclarativeParticle &p)

{

    if (!p.data) {

        Data *d = new Data;

        p.data = (void*)d;

        d->x_targetV = p.x_velocity;

        d->y_targetV = p.y_velocity;

        d->x_peak = _xvariance;

        d->y_peak = _yvariance;

        d->x_var = _pace * qreal(qrand()) / RAND_MAX / 1000.0;

        d->y_var = _pace * qreal(qrand()) / RAND_MAX / 1000.0;

    }

}

void QDeclarativeParticleMotionWander::destroy(QDeclarativeParticle &p)

{

    if (p.data)

        delete (Data*)p.data;

}

void QDeclarativeParticleMotionWander::setXVariance(qreal var)

{

    qreal scaledVar = var / 1000.0;

    if (qFuzzyCompare(scaledVar, _xvariance))

        return;

    _xvariance = scaledVar;

    emit xvarianceChanged();

}

void QDeclarativeParticleMotionWander::setYVariance(qreal var)

{

    qreal scaledVar = var / 1000.0;

    if (qFuzzyCompare(scaledVar, _yvariance))

        return;

    _yvariance = scaledVar;

    emit yvarianceChanged();

}

void QDeclarativeParticleMotionWander::setPace(qreal pace)

{

    qreal scaledPace = pace / 1000.0;

    if (qFuzzyCompare(scaledPace, _pace))

        return;

    _pace = scaledPace;

    emit paceChanged();

}

//---------------------------------------------------------------------------

class QDeclarativeParticlesPainter : public QDeclarativeItem

{

public:

    QDeclarativeParticlesPainter(QDeclarativeParticlesPrivate *p, QDeclarativeItem* parent)

        : QDeclarativeItem(parent), d(p)

    {

        setFlag(QGraphicsItem::ItemHasNoContents, false);

        maxX = minX = maxY = minY = 0;

    }

    void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);

    void updateSize();

    qreal maxX;

    qreal minX;

    qreal maxY;

    qreal minY;

    QDeclarativeParticlesPrivate* d;

};

//an animation that just gives a tick

template<class T, void (T::*method)(int)>

class TickAnimationProxy : public QAbstractAnimation

{

public:

    TickAnimationProxy(T *p, QObject *parent = 0) : QAbstractAnimation(parent), m_p(p) {}

    virtual int duration() const { return -1; }

protected:

    virtual void updateCurrentTime(int msec) { (m_p->*method)(msec); }

private:

    T *m_p;

};

//---------------------------------------------------------------------------

class QDeclarativeParticlesPrivate : public QDeclarativeItemPrivate

{

    Q_DECLARE_PUBLIC(QDeclarativeParticles)

public:

    QDeclarativeParticlesPrivate()

        : count(1), emissionRate(-1), emissionVariance(0.5), lifeSpan(1000)

        , lifeSpanDev(1000), fadeInDur(200), fadeOutDur(300)

        , angle(0), angleDev(0), velocity(0), velocityDev(0), emissionCarry(0.)

        , addParticleTime(0), addParticleCount(0), lastAdvTime(0)

        , motion(0), clock(this)

    {

    }

    ~QDeclarativeParticlesPrivate()

    {

    }

    void init()

    {

        Q_Q(QDeclarativeParticles);

        paintItem = new QDeclarativeParticlesPainter(this, q);

    }

    void tick(int time);

    void createParticle(int time);

    void updateOpacity(QDeclarativeParticle &p, int age);

    QUrl url;

    QDeclarativePixmap image;

    int count;

    int emissionRate;

    qreal emissionVariance;

    int lifeSpan;

    int lifeSpanDev;

    int fadeInDur;

    int fadeOutDur;

    qreal angle;

    qreal angleDev;

    qreal velocity;

    qreal velocityDev;

    qreal emissionCarry;

    int addParticleTime;

    int addParticleCount;

    int lastAdvTime;

    QDeclarativeParticleMotion *motion;

    QDeclarativeParticlesPainter *paintItem;

    QList<QPair<int, int> > bursts;//countLeft, emissionRate pairs

    QList<QDeclarativeParticle> particles;

    TickAnimationProxy<QDeclarativeParticlesPrivate, &QDeclarativeParticlesPrivate::tick> clock;

};

void QDeclarativeParticlesPrivate::tick(int time)

{

    Q_Q(QDeclarativeParticles);

    if (!motion)

        motion = new QDeclarativeParticleMotionLinear(q);

    int oldCount = particles.count();

    int removed = 0;

    int interval = time - lastAdvTime;

    for (int i = 0; i < particles.count(); ) {

        QDeclarativeParticle &particle = particles[i];

        int age = time - particle.birthTime;

        if (age >= particle.lifeSpan)  {

            QDeclarativeParticle part = particles.takeAt(i);

            motion->destroy(part);

            ++removed;

        } else {

            updateOpacity(particle, age);

            motion->advance(particle, interval);

            ++i;

        }

    }

    if(emissionRate == -1)//Otherwise leave emission to the emission rate

        while(removed-- && ((count == -1) || particles.count() < count))

            createParticle(time);

    if (!addParticleTime)

        addParticleTime = time;

    //Possibly emit new particles

    if (((count == -1) || particles.count() < count) && emissionRate

            && !(count==-1 && emissionRate==-1)) {

        int emissionCount = -1;

        if (emissionRate != -1){

            qreal variance = 1.;

            if (emissionVariance > 0.){

                variance += (qreal(qrand())/RAND_MAX) * emissionVariance * (qrand()%2?-1.:1.);

            }

            qreal emission = emissionRate * (qreal(interval)/1000.);

            emission = emission * variance + emissionCarry;

            double tmpDbl;

            emissionCarry = modf(emission, &tmpDbl);

            emissionCount = (int)tmpDbl;

            emissionCount = qMax(0,emissionCount);

        }

        while(((count == -1) || particles.count() < count) &&

                (emissionRate==-1 || emissionCount--))

            createParticle(time);

    }