gls_animation.cpp

Go to the documentation of this file.

#include "gls_animation.h"

#ifdef WIN32
#pragma warning(push)
#pragma warning( disable: 4512 ) // assignment operator could not be generated
#endif
#include "display_frame.h"
#ifdef WIN32
#pragma warning(pop)
#endif
#include "disti_assert.h"
#include "gls_resources.h"
#include "group.h"

#include <algorithm>
#include <limits>
#include <sstream>

#if GLS_VERSION_MAJOR < 4
#  error GlsAnimation not tested with older versions of GL Studio. Use 4.x or higher.
#endif

namespace disti
{
    // Static data
    const GlsAnimationSubsetAdapter::KeyPair GlsAnimationSubsetAdapter::s_nanPair = std::make_pair( Detail::g_nan, Detail::g_nan );

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<double>* keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _doubleCurve( keyframeCurve )
        , _baseCurve( keyframeCurve )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<Vector>* keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _vectorCurve( keyframeCurve )
        , _baseCurve( keyframeCurve )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<GlsQuaternionD>* keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _quaternionCurve( keyframeCurve )
        , _baseCurve( keyframeCurve )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<std::string>* keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _stringCurve( keyframeCurve )
        , _baseCurve( keyframeCurve )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<glsColor>* keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _colorCurve( keyframeCurve )
        , _baseCurve( keyframeCurve )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<double>::PtrConst& keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _doubleCurve( keyframeCurve )
        , _baseCurve( keyframeCurve.get() )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<Vector>::PtrConst& keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _vectorCurve( keyframeCurve )
        , _baseCurve( keyframeCurve.get() )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<GlsQuaternionD>::PtrConst& keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _quaternionCurve( keyframeCurve )
        , _baseCurve( keyframeCurve.get() )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<std::string>::PtrConst& keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _stringCurve( keyframeCurve )
        , _baseCurve( keyframeCurve.get() )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<glsColor>::PtrConst& keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _colorCurve( keyframeCurve )
        , _baseCurve( keyframeCurve.get() )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<double>::Ptr& keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _doubleCurve( keyframeCurve )
        , _baseCurve( keyframeCurve.get() )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<Vector>::Ptr& keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _vectorCurve( keyframeCurve )
        , _baseCurve( keyframeCurve.get() )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<GlsQuaternionD>::Ptr& keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _quaternionCurve( keyframeCurve )
        , _baseCurve( keyframeCurve.get() )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<std::string>::Ptr& keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _stringCurve( keyframeCurve )
        , _baseCurve( keyframeCurve.get() )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::GlsKeyframeAnimation( const std::string& name, const std::string& propertyName, const GlsKeyframeCurve<glsColor>::Ptr& keyframeCurve )
        : GlsAnimation( name )
        , _propertyName( propertyName )
        , _attr( 0 )
        , _object( 0 )
        , _key( Detail::g_nan )
        , _colorCurve( keyframeCurve )
        , _baseCurve( keyframeCurve.get() )
    {
        DistiAssert( keyframeCurve->GetKeyframeCount() > 0 );
    }

    GlsKeyframeAnimation::Key GlsKeyframeAnimation::GetKeyRange() const
    {
        const KeyPair minMax = GetMinMaxKeys();
        return minMax.second - minMax.first;
    }

    GlsKeyframeAnimation::KeyPair GlsKeyframeAnimation::GetMinMaxKeys() const
    {
        return _baseCurve->GetMinMaxKeys();
    }

    GlsKeyframeAnimation::Key GlsKeyframeAnimation::GetKey() const
    {
        return _key;
    }

    void GlsKeyframeAnimation::SetKey( const Key& key )
    {
        if( !IsReadyToAnimate() )
        {
          #ifdef GLS_DEBUG
            std::cout << "Warning -- GlsKeyframeAnimation ('" << _propertyName << "'): DisplayFrame was not set or properties were not found. Ignoring call to SetKey().\n";
          #endif
            return;
        }

        // Cache the value
        _key = key;

        // Write to the resource
        if( _doubleCurve )
        {
            (*_attr) << _doubleCurve->Interpolate( key );
        }
        else if( _vectorCurve )
        {
            const Vector vec = _vectorCurve->Interpolate( key );
          #if GLS_VERSION_MAJOR == 4 && GLS_VERSION_MINOR < 5
            if( _object )
            {
                // Handle a special case since GLS 4.5 fixed a bug with dynamic translate and scale
                if( _isDynamicTranslate )
                {
                    _object->DynamicTranslate( vec );
                }
                else
                {
                    _object->DynamicScale( vec );
                }
            }
            else
          #endif // GLS Version < 4.5
            {
                // Normal processing
                (*_attr) << vec;
            }
        }
        else if( _stringCurve )
        {
            (*_attr) << _stringCurve->Interpolate( key );
        }
        else if( _colorCurve )
        {
            // Handle a special case since we can't access the fill color from the Resources API
            const glsColor color = _colorCurve->Interpolate( key );
            if( _object )
            {
                _object->SetFillColor( color );
            }
            else
            {
                // Normal processing
                (*_attr) << color;
            }
        }
        else
        {
            (*_attr) << _quaternionCurve->Interpolate( key );
        }
    }

    void GlsKeyframeAnimation::Reset()
    {
        _key = Detail::g_nan;
    }

    std::vector<std::string> GlsKeyframeAnimation::GetPropertyNames() const
    {
        return std::vector<std::string>( &_propertyName, &_propertyName + 1 );
    }

    void GlsKeyframeAnimation::RetargetPropertyNames( const std::vector<std::string>& propertyNames )
    {
        if( propertyNames.size() > 0 )
        {
            _propertyName = propertyNames[ 0 ];
            if( _displayFrame != NULL )
            {
                // Re-do lookup with the new property names
                SetDisplayFrame( _displayFrame );
            }
        }
    }

    void GlsKeyframeAnimation::RetargetPropertyNames( const std::string& findStr, const std::string& replaceStr )
    {
        std::size_t startPos = 0;
        while( (startPos = _propertyName.find(findStr, startPos) ) != std::string::npos )
        {
            _propertyName.replace(startPos, findStr.length(), replaceStr);
            startPos += replaceStr.length();
        }
        if( _displayFrame != NULL )
        {
            // Re-do lookup with the new property names
            SetDisplayFrame( _displayFrame );
        }
    }
    
    GlsKeyframeAnimation::Size GlsKeyframeAnimation::CountPropertyNames() const
    {
        return 1;
    }

    bool GlsKeyframeAnimation::HandleSpecialCases( DisplayFrame* const displayFrame )
    {
        // Special case for fill color, which is not easily accessible via the Resources API
        if( _colorCurve )
        {
            // Watch for invalid entries like "FillColor", ".Blah", and "Blah."
            const std::size_t lastDotPos = _propertyName.rfind('.');
            if( lastDotPos != std::string::npos && lastDotPos != 0 && lastDotPos != _propertyName.size() - 1 )
            {
                const std::string prop = _propertyName.substr( lastDotPos + 1 );
                if( prop == "FillColor" )
                {
                    const std::string objName = _propertyName.substr( 0, lastDotPos );
                    // GLS-5297: Fix the FillColor property. (This is a little hacky.)
                    _object = displayFrame->objects->FindByNameSameFrame( objName.c_str() );
                    if( !_object )
                    {
                        _object = displayFrame->objects->FindByName( objName.c_str() );
                    }
                  #ifdef GLS_DEBUG
                    if( !_object )
                    {
                        std::cout << "Warning -- GlsKeyframeAnimation: '" << objName << "' was not found for FillColor pseudo-property. (Is the object name correct?)\n";
                    }
                  #endif
                    return true;
                }
            }
        }
      #if GLS_VERSION_MAJOR == 4 && GLS_VERSION_MINOR < 5
        // Handle a special case since GLS 4.5 fixed a bug with dynamic translate and scale
        else if( _vectorCurve )
        {
            // Watch for invalid entries like "FillColor", ".Blah", and "Blah."
            const std::size_t lastDotPos = _propertyName.rfind('.');
            if( lastDotPos != std::string::npos && lastDotPos != 0 && lastDotPos != _propertyName.size() - 1 )
            {
                const std::string prop = _propertyName.substr( lastDotPos + 1 );
                _isDynamicTranslate = (prop == "DynamicTranslate");
                if( _isDynamicTranslate || prop == "DynamicScale" )
                {
                    const std::string objName = _propertyName.substr( 0, lastDotPos );
                    _object = displayFrame->objects->FindByNameSameFrame( objName.c_str() );
                    if( !_object )
                    {
                        _object = displayFrame->objects->FindByName( objName.c_str() );
                    }
                  #ifdef GLS_DEBUG
                    if( !_object )
                    {
                        std::cout << "Warning -- GlsKeyframeAnimation: '" << objName << "' was not found for " << prop << " property. (Is the object name correct?)\n";
                    }
                  #endif
                    // This special case only applies to groups
                    if( dynamic_cast<Group*>( _object ) )
                    {
                        return true;
                    }
                    _object = 0;
                }
            }
        }
      #endif // GLS Version < 4.5
        return false;
    }

    bool GlsKeyframeAnimation::SetDisplayFrame( DisplayFrame* const displayFrame )
    {
        DistiAssert( displayFrame );
        _displayFrame = displayFrame;
        if( HandleSpecialCases( displayFrame ) )
        {
            return true;
        }

        // Get the resource attribute
        _attr = &displayFrame->Resource( _propertyName.c_str() );

        // If we can cast to the ampty attribute, then the attribute did not exist.
        if( dynamic_cast<DistiEmptyAttribute*>( _attr ) )
        {
          #ifdef GLS_DEBUG
            std::cout << "Warning -- GlsKeyframeAnimation: '" << _propertyName << "' was not found. (Does the property exist? Do you need to enable Runtime Attributes in the GL Studio Resources window?)\n";
          #endif
            _attr = 0; // Set back to no good
            return false;
        }
        return true;
    }

    bool GlsKeyframeAnimation::IsReadyToAnimate() const
    {
        // True if either our normal case or our special case for fill color is set
        return _attr || _object;
    }

    GlsAnimation::Ptr GlsKeyframeAnimation::Clone() const
    {
        return GlsAnimation::Ptr( new GlsKeyframeAnimation( *this ) );
    }

    GlsAnimationCollection::GlsAnimationCollection( const std::string& name, GlsAnimation* animation /*= 0*/ )
        : GlsAnimation( name )
        , _key( Detail::g_nan )
        , _minKey(  std::numeric_limits<Key>::infinity()  )
        , _maxKey( -std::numeric_limits<Key>::infinity()  )
    {
        if( animation )
        {
            Add( animation );
        }
    }

    GlsAnimationCollection::GlsAnimationCollection( const std::string& name, const GlsAnimation::Ptr& animation )
        : GlsAnimation( name )
        , _key( Detail::g_nan )
        , _minKey(  std::numeric_limits<Key>::infinity()  )
        , _maxKey( -std::numeric_limits<Key>::infinity()  )
    {
        DistiAssert( animation );
        Add( animation );
    }

    void GlsAnimationCollection::Add( GlsAnimation* const animation )
    {
        Add( GlsAnimation::Ptr( animation ) );
    }

    void GlsAnimationCollection::Add( const GlsAnimation::Ptr& animation )
    {
        // Check preconditions
        DistiAssert( animation );
        DistiAssert( !Detail::IsNaN( animation->GetKeyRange() ) );
        DistiAssert(  Detail::IsNaN( _key ) && "This animation has already been started. Cannot add to it now." );

        // Add to our list
        _animationList.push_back( animation );

        // Update min and max keys
        const KeyPair minMax = animation->GetMinMaxKeys();
        _minKey = (std::min)( _minKey, minMax.first  );
        _maxKey = (std::max)( _maxKey, minMax.second );
    }

    GlsAnimationCollection::Key GlsAnimationCollection::GetKeyRange() const
    {
        if( _animationList.empty() )
        {
            return Detail::g_nan;
        }
        return _maxKey - _minKey;
    }

    GlsAnimationCollection::KeyPair GlsAnimationCollection::GetMinMaxKeys() const
    {
        if( _animationList.empty() )
        {
            return KeyPair( Detail::g_nan, Detail::g_nan );
        }
        return KeyPair( _minKey, _maxKey );
    }

    bool GlsAnimationCollection::SetDisplayFrame( DisplayFrame* const displayFrame )
    {
        // Preconditions
        DistiAssert( displayFrame );
        bool allPropsFound = true;
        _displayFrame = displayFrame;
        for( AnimationIter it = _animationList.begin(), end = _animationList.end(); it != end; ++it )
        {
            const bool thisPropFound = (*it)->SetDisplayFrame( displayFrame );
            allPropsFound = allPropsFound && thisPropFound;
        }
        return allPropsFound;
    }

    bool GlsAnimationCollection::IsReadyToAnimate() const
    {
        if( _animationList.empty() )
        {
            return false;
        }

        for( AnimationIter it = _animationList.begin(), end = _animationList.end(); it != end; ++it )
        {
            if( !(*it)->IsReadyToAnimate() )
            {
                return false;
            }
        }
        return true;
    }

    void GlsAnimationCollection::SetKey( const Key& key )
    {
        DistiAssert( !Detail::IsNaN( key ) );
        _key = key;
        for( AnimationIter it = _animationList.begin(), end = _animationList.end(); it != end; ++it )
        {
            (*it)->SetKey( key );
        }
    }

    //bool GlsAnimationCollection::HasEnded( const double direction ) const
    //{
    //    if( direction > 0 ) // Moving forward
    //    {
    //        return (_key > _maxKey || Equal( _key, _maxKey )) // Greater-than-or-float-equal
    //            && !Detail::IsNaN( _key );                    // AND has key been set
    //    }
    //    else // Moving backward or not at all
    //    {
    //        return (_key < _minKey || Equal( _key, _minKey )) // Less-than-or-float-equal
    //            && !Detail::IsNaN( _key );                    // AND has key been set
    //    }
    //}

    void GlsAnimationCollection::Reset()
    {
        _key = Detail::g_nan;
        for( AnimationIter it = _animationList.begin(), end = _animationList.end(); it != end; ++it )
        {
            (*it)->Reset();
        }
    }

    std::vector<std::string> GlsAnimationCollection::GetPropertyNames() const
    {
        std::vector<std::string> nameList;
        nameList.reserve( _animationList.size() );
        for( AnimationIter it = _animationList.begin(), end = _animationList.end(); it != end; ++it )
        {
            const std::vector<std::string> childNames = (*it)->GetPropertyNames();
            nameList.insert( nameList.end(), childNames.begin(), childNames.end() );
        }
        return nameList;
    }

    void GlsAnimationCollection::RetargetPropertyNames( const std::vector<std::string>& propertyNames )
    {
        Size i=0;
        for( AnimationIter it = _animationList.begin(), end = _animationList.end(); it != end; ++it )
        {
            if( i < propertyNames.size() )
            {
                std::vector<std::string> collectedNames;
                Size j;
                for(j = 0; j < (*it)->CountPropertyNames(); ++j)
                {
                    collectedNames.push_back(propertyNames[ i ]);
                    i++;
                }

                (*it)->RetargetPropertyNames(collectedNames);
            }
            else
            {
              #ifdef GLS_DEBUG
                std::cout << "Warning -- GlsKeyframeAnimation: More objects than names. \n";
              #endif
                break;
            }
        }
        if( i < propertyNames.size() )
        {
              #ifdef GLS_DEBUG
                std::cout << "Warning -- GlsKeyframeAnimation: More names than objects. \n";
              #endif
        }
    }

    void GlsAnimationCollection::RetargetPropertyNames( const std::string& findStr, const std::string& replaceStr )
    {
        for( AnimationIter it = _animationList.begin(), end = _animationList.end(); it != end; ++it )
        {
            (*it)->RetargetPropertyNames( findStr, replaceStr );
        }
    }

    GlsAnimationCollection::Size GlsAnimationCollection::CountPropertyNames() const
    {
        Size sum = 0;
        //for everything in the animation list (collection or animation)
        for( AnimationIter it = _animationList.begin(), end = _animationList.end(); it != end; ++it )
        {
            sum += (*it)->CountPropertyNames();
        }
        return sum;
    }

    GlsAnimation::Ptr GlsAnimationCollection::Clone() const
    {
        GlsAnimationCollection::Ptr clone( new GlsAnimationCollection( GetName() ) );
        for( AnimationIter it = _animationList.begin(), end = _animationList.end(); it != end; ++it )
        {
            clone->Add( (*it)->Clone() );
        }
        return clone;
    }
    
    void SetGlsAnimationParentChildRelationship( DisplayObject* const parent, DisplayObject* const child )
    {
        Group* const parentsGroup = parent->ParentGroup();
        Group* const childsGroup = child->ParentGroup();

        int pos = parentsGroup->Position( parent );

        parentsGroup->DeleteObject( parent );
        childsGroup->DeleteObject( child );

        const std::string name = parent->InstanceName();
        parent->InstanceName( (name + "_Parent").c_str() );

        Group* group = new Group();
        group->InstanceName( name.c_str() );
        group->InsertObject( parent );
        group->InsertObject( child );
        group->SetAvailableAttributes( unsigned( DisplayObject::GLS_ATTRIBUTES_ALL ) );
        parentsGroup->InsertObject( group, true, true, pos );
        group->WorldRotationPoint( parent->WorldRotationPoint() );
    }

    void DumpResourceNames( DisplayFrame* const displayFrame, std::ostream& stream )
    {
        DistiAssert( displayFrame );
        GlsResourceFilter filter;
        filter.NamesOnly( true );
        filter.GroupLevelsDown( -1 );
        displayFrame->GetResources( stream, &filter );
    }
} // namespace disti