gls_animation.h

Go to the documentation of this file.

#ifndef INCLUDED_GLS_ANIMATION_H
#define INCLUDED_GLS_ANIMATION_H

#include <vector>
#include <string>

#include "gls_keyframe.h"

namespace disti
{
    // Forward declarations
    class DisplayFrame;
    class DistiAttributeBase;

    class GlsAnimation
    {
    public:
        typedef stdortr1::shared_ptr<GlsAnimation> Ptr;     
        typedef GlsKeyframeCurveBase::Key          Key;     
        typedef GlsKeyframeCurveBase::KeyPair      KeyPair; 
        typedef GlsKeyframeCurveBase::Size         Size;    

        virtual ~GlsAnimation() {}

        virtual bool SetDisplayFrame( DisplayFrame* displayFrame ) = 0;

        virtual bool IsReadyToAnimate() const = 0;

        virtual Key GetKey() const = 0;

        virtual void SetKey( const Key& key ) = 0;

        virtual Key GetKeyRange() const = 0;

        virtual KeyPair GetMinMaxKeys() const = 0;

        virtual void Reset() = 0;

        const std::string& GetName() const { return _name; }

        virtual GlsAnimation::Ptr Clone() const = 0;

        virtual std::vector<std::string> GetPropertyNames() const = 0;
 
        virtual void RetargetPropertyNames( const std::vector<std::string>& propertyNames ) = 0;
 
        virtual void RetargetPropertyNames( const std::string& findStr, const std::string& replaceStr ) = 0;

        virtual Size CountPropertyNames() const = 0;

    protected:

        GlsAnimation( const std::string& name ) : _displayFrame( NULL ), _name( name ) {}
        DisplayFrame* _displayFrame;

    private:

        // Member data
        std::string   _name;
    };

    class GlsKeyframeAnimation : public GlsAnimation
    {
    public:
        typedef stdortr1::shared_ptr<GlsKeyframeAnimation> Ptr; 

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<double>*         keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<Vector>*         keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<GlsQuaternionD>* keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<std::string>*    keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<glsColor>*       keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<double>::PtrConst&         keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<Vector>::PtrConst&         keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<GlsQuaternionD>::PtrConst& keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<std::string>::PtrConst&    keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<glsColor>::PtrConst&       keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<double>::Ptr&         keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<Vector>::Ptr&         keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<GlsQuaternionD>::Ptr& keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<std::string>::Ptr&    keyframeCurve );

        GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<glsColor>::Ptr&       keyframeCurve );

        bool SetDisplayFrame( DisplayFrame* displayFrame ); // override

        bool IsReadyToAnimate() const; // override

        Key GetKey() const; // override

        void SetKey( const Key& key ); // override

        Key GetKeyRange() const; // override

        KeyPair GetMinMaxKeys() const; // override

        void Reset(); // override

        GlsAnimation::Ptr Clone() const; // override

        std::vector<std::string> GetPropertyNames() const; // override
        
        void RetargetPropertyNames( const std::vector<std::string>& propertyNames ); // override
        
        void RetargetPropertyNames( const std::string& findStr, const std::string& replaceStr ); // override

        Size CountPropertyNames() const; // override

    private:
        // Member functions
        DistiAttributeBase& LookupResourceAttribute( DisplayFrame* displayFrame, const std::string& propertyName );
        bool                HandleSpecialCases( DisplayFrame* displayFrame ); // Returns whether a special case was found

        // Data members
        // The owned pointers (could use boost::variant or similar to avoid unused pointers)
        GlsKeyframeCurve<double        >::PtrConst _doubleCurve;
        GlsKeyframeCurve<Vector        >::PtrConst _vectorCurve;
        GlsKeyframeCurve<glsColor      >::PtrConst _colorCurve;
        GlsKeyframeCurve<GlsQuaternionD>::PtrConst _quaternionCurve;
        GlsKeyframeCurve<std::string   >::PtrConst _stringCurve;

        const GlsKeyframeCurveBase* _baseCurve; // Observer of owned shared_ptr
        std::string                 _propertyName;
        DistiAttributeBase*         _attr;
        DisplayObject*              _object; // Observer for fill color which can't be set by the Resources API
        Key                         _key;
        bool                        _isEmitEvent;   
        std::string                 _lastEmitted;

      #if GLS_VERSION_MAJOR == 4 && GLS_VERSION_MINOR < 5
        bool                        _isDynamicTranslate;
      #endif // GLS Version < 4.5
    };

    class GlsAnimationCollection : public GlsAnimation
    {
    public:
        typedef stdortr1::shared_ptr<GlsAnimationCollection> Ptr;     
        typedef GlsKeyframeCurveBase::Key                    Key;     
        typedef GlsKeyframeCurveBase::KeyPair                KeyPair; 

        explicit GlsAnimationCollection( const std::string& name, GlsAnimation* animation = 0 );

        explicit GlsAnimationCollection( const std::string& name, const GlsAnimation::Ptr& animation );

        void Add( GlsAnimation* animation );

        void Add( const GlsAnimation::Ptr& animation );

        Key GetKeyRange() const; // override

        KeyPair GetMinMaxKeys() const; // override

        bool SetDisplayFrame( DisplayFrame* displayFrame ); // override

        bool IsReadyToAnimate() const; // override

        Key GetKey() const { return _key; } // override

        void SetKey( const Key& key ); // override

        void Reset(); // override

        GlsAnimation::Ptr Clone() const; // override

        Size GetAnimationCount() const { return _animationList.size(); }

        std::vector<std::string> GetPropertyNames() const; // override
        
        void RetargetPropertyNames( const std::vector<std::string>& propertyNames ); // override
        
        void RetargetPropertyNames( const std::string& findStr, const std::string& replaceStr ); // override

        Size CountPropertyNames() const; // override

    private:
        // Types
        typedef std::vector< GlsAnimation::Ptr >  AnimationList;
        typedef AnimationList::const_iterator                      AnimationIter;

        // Member data
        Key           _key;
        Key           _minKey;
        Key           _maxKey;
        AnimationList _animationList;  // Owns the animations in it
        bool          _isStarted;
    };

    class GlsAnimationReversalAdapter : public GlsAnimation
    {
    public:
        GlsAnimationReversalAdapter( const std::string& name, GlsAnimation* animation )
            : GlsAnimation( name )
            , _animation( animation )
        {
            DistiAssert( animation );
            _minMax = animation->GetMinMaxKeys();
        }

        GlsAnimationReversalAdapter( const std::string& name, const GlsAnimation::Ptr& animation )
            : GlsAnimation( name )
            , _animation( animation )
        {
            DistiAssert( animation );
            _minMax = animation->GetMinMaxKeys();
        }

        bool SetDisplayFrame( DisplayFrame* displayFrame ) // override
        {
            return _animation->SetDisplayFrame( displayFrame );
        }

        bool IsReadyToAnimate() const // override
        {
            return _animation->IsReadyToAnimate();
        }

        Key GetKey() const // override
        {
            return _minMax.second - _animation->GetKey() + _minMax.first;
        }

        void SetKey( const Key& key ) // override
        {
            _animation->SetKey( _minMax.second - key + _minMax.first );
        }

        Key GetKeyRange() const // override
        {
            return _animation->GetKeyRange();
        }

        KeyPair GetMinMaxKeys() const // override
        {
            return _animation->GetMinMaxKeys();
        }

        void Reset() // override
        {
            _animation->Reset();
        }
        
        virtual std::vector<std::string> GetPropertyNames() const // override
        {
            return _animation->GetPropertyNames();
        }
        
        virtual void RetargetPropertyNames( const std::vector<std::string>& propertyNames ) // override
        {
            _animation->RetargetPropertyNames(propertyNames);
        }
        
        virtual void RetargetPropertyNames( const std::string& findStr, const std::string& replaceStr ) // override
        {
            _animation->RetargetPropertyNames(findStr, replaceStr);
        }

        GlsAnimation::Ptr Clone() const // override
        {
            return GlsAnimation::Ptr( new GlsAnimationReversalAdapter( GetName(), _animation->Clone() ) );
        }

        Size CountPropertyNames() const // override
        {
            return _animation->CountPropertyNames();
        }

    private:
        GlsAnimation::Ptr _animation;
        KeyPair                            _minMax;
    };

    typedef GlsAnimationReversalAdapter GlsAnimationReverser; 

    class GlsAnimationSubsetAdapter : public GlsAnimation
    {
    public:
        static const KeyPair s_nanPair;

        GlsAnimationSubsetAdapter( const std::string& name, GlsAnimation* animation, const KeyPair& clampLimits, const KeyPair& newMinMax = s_nanPair )
            : GlsAnimation( name )
            , _animation( animation )
            , _currentKey( Detail::g_nan )
        {
            DistiAssert( animation );
            Init( clampLimits, newMinMax );
        }

        GlsAnimationSubsetAdapter( const std::string& name, const GlsAnimation::Ptr& animation, const KeyPair& clampLimits, const KeyPair& newMinMax = s_nanPair )
            : GlsAnimation( name )
            , _animation( animation )
            , _currentKey( Detail::g_nan )
        {
            DistiAssert( animation );
            Init( clampLimits, newMinMax );
        }

        bool SetDisplayFrame( DisplayFrame* displayFrame ) // override
        {
            return _animation->SetDisplayFrame( displayFrame );
        }

        bool IsReadyToAnimate() const // override
        {
            return _animation->IsReadyToAnimate();
        }

        Key GetKey() const // override
        {
            return _currentKey;
        }

        void SetKey( const Key& key ) // override
        {
            _currentKey = key;

            // Convert incoming key, which is in the remapped key range, to a percentage 
            // then into contained animation's (clamped) key range
            Key clampedKey = ( key - _remappedMinMax.first ) 
                           / ( _remappedMinMax.second  - _remappedMinMax.first  )
                           * ( _animationMinMax.second - _animationMinMax.first ) 
                           + _animationMinMax.first;
            
            clampedKey = (std::max)( (std::min)( clampedKey, _clampLimits.second ), _clampLimits.first ); // Extra parens avoid the NOMINMAX issues on Windows

            _animation->SetKey( clampedKey );
        }

        Key GetKeyRange() const // override
        {
            const KeyPair minMaxKeys = GetMinMaxKeys();
            return minMaxKeys.second - minMaxKeys.first;
        }

        KeyPair GetMinMaxKeys() const // override
        {
            if( _remappedMinMax == _animationMinMax )
            {
                return _clampLimits;
            }
            else
            {
                return _remappedMinMax;
            }
        }

        void Reset() // override
        {
            _animation->Reset();
        }
        
        virtual std::vector<std::string> GetPropertyNames() const // override
        {
            return _animation->GetPropertyNames();
        }
        
        virtual void RetargetPropertyNames( const std::vector<std::string>& propertyNames ) // override
        {
            _animation->RetargetPropertyNames(propertyNames);
        }
        
        virtual void RetargetPropertyNames( const std::string& findStr, const std::string& replaceStr ) // override
        {
            _animation->RetargetPropertyNames(findStr, replaceStr);
        }

        GlsAnimation::Ptr Clone() const // override
        {
            return GlsAnimation::Ptr( new GlsAnimationSubsetAdapter( GetName(), _animation->Clone(), _clampLimits, _remappedMinMax ) );
        }

        Size CountPropertyNames() const // override
        {
            return _animation->CountPropertyNames();
        }

    private:
        void Init( const KeyPair& clampLimits, const KeyPair& newMinMax )
        {
            const bool isMinMaxNaN = Detail::IsNaN( newMinMax.first ) || Detail::IsNaN( newMinMax.second );

            // Preconditions of the constructors
            DistiAssert( clampLimits.first <= clampLimits.second );
            DistiAssert( newMinMax.first <= newMinMax.second || isMinMaxNaN );

            // Clamps the given begin and end values within the animation's limits
            // (Extra parens avoid the NOMINMAX issues on Windows)
            _animationMinMax = _animation->GetMinMaxKeys();
            _clampLimits = std::make_pair(
                (std::max)( clampLimits.first,  _animationMinMax.first  ),
                (std::min)( clampLimits.second, _animationMinMax.second ) );

            if( isMinMaxNaN )
            {
                _remappedMinMax = _animationMinMax;
            }
            else
            {
                _remappedMinMax = newMinMax;
            }
        }

        // Data members
        GlsAnimation::Ptr _animation;
        KeyPair           _animationMinMax;
        KeyPair           _clampLimits;
        KeyPair           _remappedMinMax;
        Key               _currentKey;
    };

    GlsAnimation::Ptr LoadAnimationScript( const std::string& filename );

    GlsAnimation::Ptr LoadAnimationScriptFromString(const std::string& script);

#ifdef GLS_ANIMATION_ENABLE_ZIP_LOADING
    std::vector< GlsAnimation::Ptr > LoadAnimationZip( const std::string& filename );
#endif

    // Names of all the interpolators
    const std::string g_linearInterpTag = "linear";              
    const std::string g_gatedInterpTag  = "gated";               
    const std::string g_slerpTag        = "slerp";               
    const std::string g_quadInTag       = "quadraticIn";         
    const std::string g_quadOutTag      = "quadraticOut";        
    const std::string g_quadInOUtTag    = "quadraticInAndOut";   
    const std::string g_cubeInTag       = "cubicIn";             
    const std::string g_cubeOutTag      = "cubicOut";            
    const std::string g_cubeInOutTag    = "cubicInAndOut";       
    const std::string g_quartInTag      = "quarticIn";           
    const std::string g_quartOutTag     = "quarticOut";          
    const std::string g_quartInOutTag   = "quarticInAndOut";     
    const std::string g_quintInTag      = "quinticIn";           
    const std::string g_quintOutTag     = "quinticOut";          
    const std::string g_quintInOutTag   = "quinticInAndOut";     
    const std::string g_sinInTag        = "sinusoidalIn";        
    const std::string g_sinOutTag       = "sinusoidalOut";       
    const std::string g_sinInOutTag     = "sinusoidalInAndOut";  
    const std::string g_expoInTag       = "exponentIn";          
    const std::string g_expoOutTag      = "exponentOut";         
    const std::string g_expoInOutTag    = "exponentInAndOut";    
    const std::string g_circleInTag     = "circularIn";          
    const std::string g_circleOutTag    = "circularOut";         
    const std::string g_circleInOutTag  = "circularInAndOut";    
    const std::string g_elasticInTag    = "elasticIn";           
    const std::string g_elasticOutTag   = "elasticOut";          
    const std::string g_elasticInOutTag = "elasticInAndOut";     
    const std::string g_bounceInTag     = "bounceIn";            
    const std::string g_bounceOutTag    = "bounceOut";           
    const std::string g_bounceInOutTag  = "bounceInAndOut";      
    const std::string g_backInTag       = "backIn";              
    const std::string g_backOutTag      = "backOut";             
    const std::string g_backInOutTag    = "backInAndOut";        

    namespace Detail
    {
        template<bool B, class T = void> struct enable_if {};
        template<class T>                struct enable_if<true, T> { typedef T type; };

        template <typename T, typename U> struct is_same      { enum { value = false }; };
        template <typename T>             struct is_same<T,T> { enum { value = true  }; };

        template <typename T, typename U, typename V> struct is_same2 { enum { value = is_same<T,U>::value || is_same<T,V>::value }; };
    
        template <class T, class U>
        struct is_convertible
        {
        private:
            typedef char Small;
            struct Big { char dummy[2]; };
            static Big   Test(...);
            static Small Test(U);
            static T MakeT();
        public:
            enum { value = sizeof(Small) == sizeof((Test(MakeT()))) };
        };
    
        template <class T> struct is_convertible<T,    T   > { enum { value = true  }; }; //< Replacement for std::is_convertible, adapted from Loki 0.1.7.
        template <class T> struct is_convertible<void, T   > { enum { value = false }; }; //< Replacement for std::is_convertible, adapted from Loki 0.1.7.
        template <class T> struct is_convertible<T,    void> { enum { value = false }; }; //< Replacement for std::is_convertible, adapted from Loki 0.1.7.
        template<>         struct is_convertible<void, void> { enum { value = true  }; }; //< Replacement for std::is_convertible, adapted from Loki 0.1.7.

        template<class Value>
        typename GlsKeyframeInterpolator<Value>::Ptr CreateSlerp( typename enable_if< is_same2< Value, Vector, GlsQuaternionD >::value >::type* = 0 )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsSphericalLinearInterpolator<Value>() );
        }

        template<class Value>
        typename GlsKeyframeInterpolator<Value>::Ptr CreateSlerp( typename enable_if< !is_same2< Value, Vector, GlsQuaternionD >::value >::type* = 0 )
        {
            std::cerr << "GlsAnimation: Slerp requested for a type that does not support it.\n";
            return typename GlsKeyframeInterpolator<Value>::Ptr();
        }
    }

    template<class Value>
    typename GlsKeyframeInterpolator<Value>::Ptr CreateInterpolator( const std::string& name, typename Detail::enable_if< !Detail::is_same2< Value, glsColor, std::string >::value >::type* = 0 )
    {
        if( name.empty() )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new typename Detail::DefaultInterpolator<Value>::Type() );
        }
        else if( name == g_linearInterpTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsLinearInterpolator<Value>() );
        }
        else if( name == g_gatedInterpTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsGatedInterpolator<Value>() );
        }
        else if( name == g_slerpTag )
        {
            return Detail::CreateSlerp<Value>();
        }
        else if( name == g_quadInTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsQuadraticEaseInInterpolator<Value>() );
        }
        else if( name == g_quadOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsQuadraticEaseOutInterpolator<Value>() );
        }
        else if( name == g_quadInOUtTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsQuadraticEaseInOutInterpolator<Value>() );
        }
        else if( name == g_cubeInTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsCubicEaseInInterpolator<Value>() );
        }
        else if( name == g_cubeOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsCubicEaseOutInterpolator<Value>() );
        }
        else if( name == g_cubeInOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsCubicEaseInOutInterpolator<Value>() );
        }
        else if( name == g_quartInTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsQuarticEaseInInterpolator<Value>() );
        }
        else if( name == g_quartOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsQuarticEaseOutInterpolator<Value>() );
        }
        else if( name == g_quartInOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsQuarticEaseInOutInterpolator<Value>() );
        }
        else if( name == g_quintInTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsQuinticEaseInInterpolator<Value>() );
        }
        else if( name == g_quintOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsQuinticEaseOutInterpolator<Value>() );
        }
        else if( name == g_quintInOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsQuinticEaseInOutInterpolator<Value>() );
        }
        else if( name == g_sinInTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsSinusoidalEaseInInterpolator<Value>() );
        }
        else if( name == g_sinOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsSinusoidalEaseOutInterpolator<Value>() );
        }
        else if( name == g_sinInOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsSinusoidalEaseInOutInterpolator<Value>() );
        }
        else if( name == g_expoInTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsExponentialEaseInInterpolator<Value>() );
        }
        else if( name == g_expoOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsExponentialEaseOutInterpolator<Value>() );
        }
        else if( name == g_expoInOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsExponentialEaseInOutInterpolator<Value>() );
        }
        else if( name == g_circleInTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsCircularEaseInInterpolator<Value>() );
        }
        else if( name == g_circleOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsCircularEaseOutInterpolator<Value>() );
        }
        else if( name == g_circleInOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsCircularEaseInOutInterpolator<Value>() );
        }
        else if( name == g_elasticInTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsElasticEaseInInterpolator<Value>() );
        }
        else if( name == g_elasticOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsElasticEaseOutInterpolator<Value>() );
        }
        else if( name == g_elasticInOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsElasticEaseInOutInterpolator<Value>() );
        }
        else if( name == g_bounceInTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsBounceEaseInInterpolator<Value>() );
        }
        else if( name == g_bounceOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsBounceEaseOutInterpolator<Value>() );
        }
        else if( name == g_bounceInOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsBounceEaseInOutInterpolator<Value>() );
        }
        else if( name == g_backInTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsBackEaseInInterpolator<Value>() );
        }
        else if( name == g_backOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsBackEaseOutInterpolator<Value>() );
        }
        else if( name == g_backInOutTag )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsBackEaseInOutInterpolator<Value>() );
        }

        std::cerr << "GlsAnimation: Unreqcognized interpolator requested: " << name << ".\n";
        return typename GlsKeyframeInterpolator<Value>::Ptr();
    }

    template<class Value>
    typename GlsKeyframeInterpolator<Value>::Ptr CreateInterpolator( const std::string& name, typename Detail::enable_if< Detail::is_same< Value, glsColor >::value >::type* = 0 )
    {
        typename GlsKeyframeInterpolator<double>::Ptr interpolator = CreateInterpolator<double>( name );
        if( !interpolator )
        {
            return typename GlsKeyframeInterpolator<Value>::Ptr();
        }
        return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsColorInterpolationAdapter( interpolator ) );
    }

    template<class Value>
    typename GlsKeyframeInterpolator<Value>::Ptr CreateInterpolator( const std::string& name, typename Detail::enable_if< Detail::is_same< Value, std::string >::value >::type* = 0 )
    {
        if( !name.empty() && name != g_gatedInterpTag )
        {
            std::cerr << "LoadAnimationScript(): Strings may only use gated interpolation, not " << name << ".\n";
        }
        return typename GlsKeyframeInterpolator<Value>::Ptr( new GlsGatedInterpolator<Value>() );
    }

    template<class Value>
    typename GlsKeyframeCurve<Value>::Ptr CreateTweenerCurve( const Value& begin, const Value& end, const GlsAnimation::Key& duration, const std::string& tweenerName )
    {
        DistiAssert( duration >= 0.0 );
        const typename GlsKeyframeInterpolator<Value>::Ptr interpolator = CreateInterpolator<Value>( tweenerName );
        if( !interpolator )
        {
            return typename GlsKeyframeCurve<Value>::Ptr();
        }
        typename GlsKeyframeCurve<Value>::Ptr curve( new GlsKeyframeCurve<Value>( interpolator ) );
        curve->AddKeyframe( 0,        begin );
        curve->AddKeyframe( duration, end   );
        return curve;
    }

    void SetGlsAnimationParentChildRelationship( DisplayObject* parent, DisplayObject* child );

    void DumpResourceNames( DisplayFrame* displayFrame, std::ostream& stream );
}

#endif