gls_animation.h

Go to the documentation of this file.

#ifndef INCLUDED_GLS_ANIMATION_H
#define INCLUDED_GLS_ANIMATION_H

#include <string>
#include <vector>

#include "gls_keyframe.h"
#include "weak_reference.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;
    WeakRef<DistiAttributeBase> _attr;
    WeakRef<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();
    }
} // namespace Detail

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 );
} // namespace disti

#endif