qskinny/src/controls/QskFlickAnimator.cpp

/******************************************************************************
 * QSkinny - Copyright (C) 2016 Uwe Rathmann
 * This file may be used under the terms of the QSkinny License, Version 1.0
 *****************************************************************************/

#include "QskFlickAnimator.h"
#include <qmath.h>

static inline qreal qskAligned( qreal value )
{
    if ( qFuzzyIsNull( value ) )
        return 0.0;

    if ( qFuzzyCompare( value, -1.0 ) )
        return -1.0;

    if ( qFuzzyCompare( value, 1.0 ) )
        return 1.0;

    return value;
}

QskFlickAnimator::QskFlickAnimator():
    m_velocity{ 0.0, 0.0 },
    m_degrees( 0.0 ),
    m_cos( 1.0 ),
    m_sin( 0.0 )
{
    setDuration( 1000 );
    setEasingCurve( QEasingCurve::OutCubic );
}

QskFlickAnimator::~QskFlickAnimator()
{
}

void QskFlickAnimator::flick( qreal degrees, qreal velocity )
{
    if ( velocity < 0.0 || qFuzzyIsNull( velocity ) )
        velocity = 0.0;

    stop();

    setAngle( degrees );

    m_velocity[0] = velocity;
    m_velocity[1] = 0.0;

    if ( m_velocity[0] > 0.0 )
        start();
}

void QskFlickAnimator::accelerate( qreal degrees, qreal velocity )
{
    if ( isRunning() && !qFuzzyIsNull( m_velocity[1] ) )
    {
        const qreal delta = qDegreesToRadians( degrees - m_degrees );

        if ( qFuzzyIsNull( delta ) )
        {
            // the same as below, but faster to calculate: exp2( 2.0 * cos( 0.0 )
            velocity += 4.0 * m_velocity[1];
        }
        else
        {
            const qreal cos = qFastCos( delta );
            if ( cos >= 0.0 )
            {
                // boosting the current velocity
                velocity += exp2( 2.0 * cos ) * m_velocity[1];
            }
            else
            {
                // slowing down
                velocity = velocity * exp2( 2.0 * cos );
            }
        }
    }

    flick( degrees, velocity );
}

void QskFlickAnimator::done()
{
    m_velocity[1] = 0.0;
    m_elapsed = 0.0;
}

void QskFlickAnimator::setAngle( qreal degrees )
{
    if ( degrees != m_degrees )
    {
        m_degrees = degrees;

        const qreal radians = qDegreesToRadians( degrees );

        m_cos = qskAligned( qFastCos( radians ) );
        m_sin = qskAligned( qFastSin( radians ) );
    }
}

void QskFlickAnimator::setVelocity( qreal velocity )
{
    m_velocity[0] = velocity;
}

void QskFlickAnimator::setup()
{
    m_elapsed = 0;
    m_velocity[1] = m_velocity[0];
}

void QskFlickAnimator::advance( qreal value )
{
    const qreal oldVelocity = m_velocity[1];
    const int oldElapsed = m_elapsed;

    m_velocity[1] = m_velocity[0] * ( 1.0 - value );
    m_elapsed = elapsed();

    const qreal duration = ( m_elapsed - oldElapsed ) / 1000.0; // in seconds
    if ( duration > 0.0 )
    {
        const qreal velocity = 0.5 * ( m_velocity[1] + oldVelocity ); // average

        /*
            Using the average velocity is not accurate, when having a non linear
            curve, but the error can be ignored
         */

        const qreal distance = duration * velocity;
        translate( m_cos * distance, m_sin * distance );
    }
}