gls_animation_juggler.h

Go to the documentation of this file.

#ifndef INCLUDED_GLS_ANIMATION_JUGGLER_H
#define INCLUDED_GLS_ANIMATION_JUGGLER_H

#include <limits>
#include <memory>
#include <vector>

#include "gls_keyframe.h"
#include "gls_animation.h"
#include "gls_animation_observer.h"

namespace disti
{
    // Forward declarations
    class DisplayFrame;

    class GlsAnimationJuggler
    {
    public:
        typedef stdortr1::shared_ptr<GlsAnimationJuggler> Ptr; 
    
        enum LoopBehavior
        {
            PLAY_ONCE, 
            LOOP,      
            PING_PONG  
        };

        typedef GlsKeyframeCurveBase::Key Key;

        typedef Detail::ID ID;

        static ID GetInvalidID();

        GlsAnimationJuggler( Key currentTime = 0 );

        ~GlsAnimationJuggler();

        template<class Animation>
        ID Schedule( 
            Animation      animation, 
            DisplayFrame*  displayFrame  = 0, 
            LoopBehavior   loop          = PLAY_ONCE,
            double         playbackSpeed = 1,
            Key            delayKey      = 0,
            Key            startKey      = Detail::g_nan, 
            Key            endKey        = Detail::g_nan)
        {
            return Schedule( animation, GlsAnimationObserverBase::Ptr(), displayFrame, loop, playbackSpeed, delayKey, startKey, endKey );
        }

        template<class Animation, class Observer>
        ID Schedule( 
            Animation     animation, 
            Observer      observer,
            DisplayFrame* displayFrame  = 0, 
            LoopBehavior  loop          = PLAY_ONCE,
            double        playbackSpeed = 1,
            Key           delayKey      = 0,
            Key           startKey      = Detail::g_nan, 
            Key           endKey        = Detail::g_nan,            
            typename Detail::enable_if< !Detail::is_convertible<Observer, DisplayFrame*>::value >::type* = 0 )
        {
            return DoSchedule( GlsAnimation::Ptr( animation ),
                               GlsAnimationObserverBase::Ptr( observer ), 
                               displayFrame, 
                               loop, 
                               playbackSpeed,
                               delayKey,
                               startKey,
                               endKey );
        }
        
        void Advance( Key dt );

        void SetKey( Key key );

        void Cancel( ID id );

        void CancelAllAnimations();

        Key GetKey( ID id ) const;
    
    private:
    
        // Types
        struct AnimationData
        {
            GlsAnimation::Ptr             animation;
            GlsAnimationObserverBase::Ptr observer;
            Key                           delayUntilKey;
            Key                           startKey;  // Used to only play a segment of the animation
            Key                           endKey;
            double                        speed;
            LoopBehavior                  loopBehavior;
            ID                            id;
            int                           direction; // Indicates whether a ping-ponging animation is going forward or backward

            AnimationData() : delayUntilKey( Detail::g_nan ), startKey( Detail::g_nan ), endKey( Detail::g_nan ), speed(1), loopBehavior( PLAY_ONCE ), id( GetInvalidID() ), direction( 1 ) 
            {
                CalcStartEndKeys();
            }

            AnimationData( const GlsAnimation::Ptr&             animation_, 
                           const GlsAnimationObserverBase::Ptr& observer_, 
                           Key                                  delayUntilKey_, 
                           Key                                  startKey_,
                           Key                                  endKey_,
                           double                               speed_, 
                           LoopBehavior                         loopBehavior_,
                           ID                                   id_ ,
                           int                                  direction_)
                : animation( animation_ )
                , observer( observer_ )
                , delayUntilKey( delayUntilKey_ )
                , startKey( startKey_ )
                , endKey( endKey_ )
                , speed( speed_ )
                , loopBehavior( loopBehavior_ )
                , id( id_ )
                , direction( direction_ )
            {
                DistiAssert( speed >= 0.0f ); 
                DistiAssert( 1==direction || -1==direction );

                CalcStartEndKeys();
            }

            void CalcStartEndKeys()
            {
                if (animation)
                {
                    // If startKey or endKey are not specified, then use the values from the animation
                    const auto animationMinMax = animation->GetMinMaxKeys();
                    if (Detail::IsNaN( startKey ) || startKey < animationMinMax.first)
                    {
                        startKey = animationMinMax.first;
                    }
                    if (Detail::IsNaN( endKey ) || endKey > animationMinMax.second)
                    {
                        endKey = animationMinMax.second;
                    }
                }
            }

        };

        static bool HasAnimationEnded( const Key& key, const AnimationData& animationData, const int direction);
    
        // Comparator for std::find_if() lookup of AnimationData by ID
        struct HasID
        {
            ID id;
            explicit HasID( ID id_ ) : id(id_) {}
            bool operator()( const AnimationData& animationData ) const { return animationData.id == id; }
        };

        typedef std::vector<AnimationData>    AnimationList;
        typedef AnimationList::iterator       AnimationIter;
        typedef AnimationList::const_iterator AnimationConstIter;

        // Data members
        Key           _currentTime;
        AnimationList _animationList;
        AnimationList _animationListAdvanceCopy; // A copy for Advance() to work on; member var to avoid frequent memory allocations
        bool          _isAnimationListAdvanceCopyStale;
        ID            _nextID;

        // Methods
        // \param notifyCompleted will be set to true to allow the juggler to send the OnCompleted notification for continuous modes
        std::pair<Key, int> ComputeKeyAndDirection( const AnimationData& animationData, Key dtm, bool& notifyCompleted ) const;

        // Helper for the template above (needed because GCC's shared_ptr 
        // doesn't support conversion from shared_ptr<Derived> to shared_ptr<Base>).
        ID DoSchedule( 
            const GlsAnimation::Ptr&             animation, 
            const GlsAnimationObserverBase::Ptr& observer,
            DisplayFrame*                        displayFrame, 
            LoopBehavior                         loop,
            double                               playbackSpeed,
            Key                                  delayKey,
            Key                                  startKey,
            Key                                  endKey   ); 

        GlsAnimationJuggler( const GlsAnimationJuggler& ); // = delete
        void operator=(      const GlsAnimationJuggler& ); // = delete
    };
}

#endif