X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fanimation%2Fscene-graph-animator.h;h=cbf0842ad713b758ae12f07d7bd8f1fedddf952a;hb=55827866fcb8c7ee47581ac4335a3390472090e8;hp=02ccfc25f18d37c3b87f74d93f5ea665e59e3315;hpb=232bcb0bbb0f60ae98f1a96da9615dab35b06074;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/animation/scene-graph-animator.h b/dali/internal/update/animation/scene-graph-animator.h old mode 100644 new mode 100755 index 02ccfc2..cbf0842 --- a/dali/internal/update/animation/scene-graph-animator.h +++ b/dali/internal/update/animation/scene-graph-animator.h @@ -1,8 +1,8 @@ -#ifndef __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__ -#define __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__ +#ifndef DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H +#define DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2019 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,12 +18,10 @@ * */ +// EXTERNAL INCLUDES +#include + // INTERNAL INCLUDES -#include -#include -#include -#include -#include #include #include #include @@ -31,6 +29,13 @@ #include #include #include +#include +#include +#include +#include +#include +#include +#include namespace Dali { @@ -38,41 +43,115 @@ namespace Dali namespace Internal { -typedef Dali::Animation::Interpolation Interpolation; - -struct AnimatorFunctionBase; +using Interpolation = Dali::Animation::Interpolation; -namespace SceneGraph +/** + * AnimatorFunction base class. + * Needs to be declared first so AnimatorBase knows about it's destructor + * All update functions must inherit from AnimatorFunctionBase and overload the appropiate "()" operator + */ +struct AnimatorFunctionBase { + /** + * Constructor + */ + AnimatorFunctionBase() {} + + /* + * Virtual destructor (Intended as base class) + */ + virtual ~AnimatorFunctionBase() {} + + ///Stub "()" operators. + virtual bool operator()(float progress, const bool& property) + { + return property; + } + + virtual float operator()(float progress, const int32_t& property) + { + return static_cast( property ); + } + + virtual float operator()(float progress, const float& property) + { + return property; + } + + virtual Vector2 operator()(float progress, const Vector2& property) + { + return property; + } -class AnimatorBase; + virtual Vector3 operator()(float progress, const Vector3& property) + { + return property; + } -typedef OwnerContainer< AnimatorBase* > AnimatorContainer; + virtual Vector4 operator()(float progress, const Vector4& property) + { + return property; + } + + virtual Quaternion operator()(float progress, const Quaternion& property) + { + return property; + } +}; -typedef AnimatorContainer::Iterator AnimatorIter; -typedef AnimatorContainer::ConstIterator AnimatorConstIter; +namespace SceneGraph +{ /** * An abstract base class for Animators, which can be added to scene graph animations. * Each animator changes a single property of an object in the scene graph. */ -class AnimatorBase +class AnimatorBase : public PropertyOwner::Observer { public: - typedef float (*AlphaFunc)(float progress); ///< Definition of an alpha function + using AlphaFunc = float (*)(float progress); ///< Definition of an alpha function + + /** + * Observer to determine when the animator is no longer present + */ + class LifecycleObserver + { + public: + /** + * Called shortly before the animator is destroyed. + */ + virtual void ObjectDestroyed() = 0; + + protected: + /** + * Virtual destructor, no deletion through this interface + */ + virtual ~LifecycleObserver() = default; + }; + /** * Constructor. */ - AnimatorBase() - : mDurationSeconds(1.0f), - mInitialDelaySeconds(0.0f), - mAlphaFunction(AlphaFunction::DEFAULT), - mDisconnectAction(Dali::Animation::BakeFinal), - mActive(false), - mEnabled(true), - mConnectedToSceneGraph(false) + AnimatorBase( PropertyOwner* propertyOwner, + AnimatorFunctionBase* animatorFunction, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod ) + : mLifecycleObserver( nullptr ), + mPropertyOwner( propertyOwner ), + mAnimatorFunction( animatorFunction ), + mDurationSeconds( timePeriod.durationSeconds ), + mIntervalDelaySeconds( timePeriod.delaySeconds ), + mSpeedFactor( 1.0f ), + mCurrentProgress( 0.f ), + mLoopCount( 1 ), + mAlphaFunction( alphaFunction ), + mDisconnectAction( Dali::Animation::BakeFinal ), + mAnimationPlaying( false ), + mEnabled( true ), + mConnectedToSceneGraph( false ), + mAutoReverseEnabled( false ) { } @@ -81,12 +160,69 @@ public: */ virtual ~AnimatorBase() { + delete mAnimatorFunction; + if (mPropertyOwner && mConnectedToSceneGraph) + { + mPropertyOwner->RemoveObserver(*this); + } + if( mLifecycleObserver != nullptr ) + { + mLifecycleObserver->ObjectDestroyed(); + } + } + + void AddLifecycleObserver( LifecycleObserver& observer ) + { + mLifecycleObserver = &observer; } + void RemoveLifecycleObserver( LifecycleObserver& observer ) + { + mLifecycleObserver = nullptr; + } + +private: // From PropertyOwner::Observer + + /** + * @copydoc PropertyOwner::Observer::PropertyOwnerConnected( PropertyOwner& owner ) + */ + void PropertyOwnerConnected( PropertyOwner& owner ) override final + { + mEnabled = true; + } + + /** + * @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) + */ + void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override final + { + // If we are active, then bake the value if required + if ( mAnimationPlaying && mDisconnectAction != Dali::Animation::Discard ) + { + // Bake to target-value if BakeFinal, otherwise bake current value + Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true ); + } + + mEnabled = false; + } + + /** + * @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed( PropertyOwner& owner ) + */ + void PropertyOwnerDestroyed( PropertyOwner& owner ) override final + { + mPropertyOwner = nullptr; + } + +public: /** * Called when Animator is added to the scene-graph in update-thread. */ - virtual void ConnectToSceneGraph() = 0; + void ConnectToSceneGraph() + { + mConnectedToSceneGraph = true; + mPropertyOwner->AddObserver(*this); + } /** * Set the duration of the animator. @@ -104,28 +240,62 @@ public: * Retrieve the duration of the animator. * @return The duration in seconds. */ - float GetDuration() + float GetDuration() const { return mDurationSeconds; } + void SetSpeedFactor( float factor ) + { + mSpeedFactor = factor; + } + + void SetLoopCount(int32_t loopCount) + { + mLoopCount = loopCount; + } + + float SetProgress( float progress ) + { + float value = 0.0f; + + if( mAutoReverseEnabled ) + { + if( mSpeedFactor > 0.0f ) + { + value = 1.0f - 2.0f * std::abs( progress - 0.5f ); + } + // Reverse mode + else if( mSpeedFactor < 0.0f ) + { + value = 2.0f * std::abs( progress - 0.5f ); + } + } + else + { + value = progress; + } + + return value; + } + /** * Set the delay before the animator should take effect. * The default is zero i.e. no delay. * @param [in] seconds The delay in seconds. */ - void SetInitialDelay(float seconds) + void SetIntervalDelay(float seconds) { - mInitialDelaySeconds = seconds; + mIntervalDelaySeconds = seconds; } /** - * Retrieve the initial delay of the animator. + * Retrieve the delay before the animator should take effect. * @return The delay in seconds. */ - float GetInitialDelay() + float GetIntervalDelay() const { - return mInitialDelaySeconds; + return mIntervalDelaySeconds; } /** @@ -146,7 +316,7 @@ public: return mAlphaFunction; } - /* + /** * Applies the alpha function to the specified progress * @param[in] Current progress * @return The progress after the alpha function has been aplied @@ -256,7 +426,7 @@ public: float upperBound(1.0f); float currentT(0.5f); float currentX = EvaluateCubicBezier( controlPoints.x, controlPoints.z, currentT); - while( fabs( progress - currentX ) > tolerance ) + while( fabsf( progress - currentX ) > tolerance ) { if( progress > currentX ) { @@ -303,33 +473,37 @@ public: */ void SetActive( bool active ) { - mActive = active; + mAnimationPlaying = active; } /** - * Retrieve whether the animator has been set to active or not. - * @return The active state. + * Whether the animator's target object is valid and on the stage. + * @return The enabled state. */ - bool GetActive() const + bool IsEnabled() const { - return mActive; + return mEnabled; } - /* - * Retrive wheter the animator's target object is valid and on the stage. - * @return The enabled state. + /** + * @brief Sets the looping mode. + * @param[in] loopingMode True when the looping mode is AUTO_REVERSE */ - bool IsEnabled() const + void SetLoopingMode( bool loopingMode ) { - return mEnabled; + mAutoReverseEnabled = loopingMode; } + /** * Returns wheter the target object of the animator is still valid * or has been destroyed. * @return True if animator is orphan, false otherwise * * @note The SceneGraph::Animation will delete any orphan animator in its Update method. */ - virtual bool Orphan() = 0; + bool Orphan() + { + return (mPropertyOwner == nullptr); + } /** * Update the scene object attached to the animator. @@ -337,7 +511,34 @@ public: * @param[in] progress A value from 0 to 1, where 0 is the start of the animation, and 1 is the end point. * @param[in] bake Bake. */ - virtual void Update(BufferIndex bufferIndex, float progress, bool bake) = 0; + void Update( BufferIndex bufferIndex, float progress, bool bake ) + { + if( mLoopCount >= 0 ) + { + // Update the progress value + progress = SetProgress( progress ); + } + + if( mPropertyOwner ) + { + mPropertyOwner->SetPropertyDirty( true ); + } + + float alpha = ApplyAlphaFunction( progress ); + + // PropertyType specific part + DoUpdate( bufferIndex, bake, alpha ); + + mCurrentProgress = progress; + } + + /** + * Type specific part of the animator + * @param bufferIndex index to use + * @param bake whether to bake or not + * @param alpha value from alpha based on progress + */ + virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) = 0; protected: @@ -354,22 +555,30 @@ protected: return 3.0f*(1.0f-t)*(1.0f-t)*t*p0 + 3.0f*(1.0f-t)*tSquare*p1 + tSquare*t; } + LifecycleObserver* mLifecycleObserver; + PropertyOwner* mPropertyOwner; + AnimatorFunctionBase* mAnimatorFunction; float mDurationSeconds; - float mInitialDelaySeconds; + float mIntervalDelaySeconds; + float mSpeedFactor; + float mCurrentProgress; + + int32_t mLoopCount; AlphaFunction mAlphaFunction; Dali::Animation::EndAction mDisconnectAction; ///< EndAction to apply when target object gets disconnected from the stage. - bool mActive:1; ///< Animator is "active" while it's running. + bool mAnimationPlaying:1; ///< whether disconnect has been applied while it's running. bool mEnabled:1; ///< Animator is "enabled" while its target object is valid and on the stage. bool mConnectedToSceneGraph:1; ///< True if ConnectToSceneGraph() has been called in update-thread. + bool mAutoReverseEnabled:1; }; /** * An animator for a specific property type PropertyType. */ template < typename PropertyType, typename PropertyAccessorType > -class Animator : public AnimatorBase, public PropertyOwner::Observer +class Animator : public AnimatorBase { public: @@ -387,18 +596,12 @@ public: AlphaFunction alphaFunction, const TimePeriod& timePeriod ) { - typedef Animator< PropertyType, PropertyAccessorType > AnimatorType; - // The property was const in the actor-thread, but animators are used in the scene-graph thread. - AnimatorType* animator = new AnimatorType( const_cast( &propertyOwner ), - const_cast( &property ), - animatorFunction ); - - animator->SetAlphaFunction( alphaFunction ); - animator->SetInitialDelay( timePeriod.delaySeconds ); - animator->SetDuration( timePeriod.durationSeconds ); - - return animator; + return new Animator( const_cast( &propertyOwner ), + const_cast( &property ), + animatorFunction, + alphaFunction, + timePeriod ); } /** @@ -406,70 +609,18 @@ public: */ virtual ~Animator() { - if (mPropertyOwner && mConnectedToSceneGraph) - { - mPropertyOwner->RemoveObserver(*this); - } - - if( mAnimatorFunction ) - { - delete mAnimatorFunction; - } - } - - /** - * Called when Animator is added to the scene-graph in update-thread. - */ - virtual void ConnectToSceneGraph() - { - mConnectedToSceneGraph = true; - mPropertyOwner->AddObserver(*this); - } - - /** - * Called when mPropertyOwner is connected to the scene graph. - */ - virtual void PropertyOwnerConnected( PropertyOwner& owner ) - { - mEnabled = true; - } - - /** - * Called when mPropertyOwner is disconnected from the scene graph. - */ - virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) - { - // If we are active, then bake the value if required - if ( mActive && mDisconnectAction != Dali::Animation::Discard ) - { - // Bake to target-value if BakeFinal, otherwise bake current value - Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true ); - } - - mActive = false; - mEnabled = false; - } - - /** - * Called shortly before mPropertyOwner is destroyed - */ - virtual void PropertyOwnerDestroyed( PropertyOwner& owner ) - { - mPropertyOwner = NULL; - mPropertyAccessor.Reset(); - mEnabled = false; } /** - * From AnimatorBase. + * @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) */ - virtual void Update( BufferIndex bufferIndex, float progress, bool bake ) + virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) override final { - float alpha = ApplyAlphaFunction(progress); - const PropertyType& current = mPropertyAccessor.Get( bufferIndex ); - const PropertyType result = (*mAnimatorFunction)( alpha, current ); + // need to cast the return value in case property is integer + const PropertyType result = static_cast( (*mAnimatorFunction)( alpha, current ) ); + if ( bake ) { mPropertyAccessor.Bake( bufferIndex, result ); @@ -478,16 +629,6 @@ public: { mPropertyAccessor.Set( bufferIndex, result ); } - - mCurrentProgress = progress; - } - - /** - * From AnimatorBase. - */ - virtual bool Orphan() - { - return (mPropertyOwner == NULL); } private: @@ -497,11 +638,11 @@ private: */ Animator( PropertyOwner* propertyOwner, PropertyBase* property, - AnimatorFunctionBase* animatorFunction ) - : mPropertyOwner( propertyOwner ), - mPropertyAccessor( property ), - mAnimatorFunction( animatorFunction ), - mCurrentProgress( 0.0f ) + AnimatorFunctionBase* animatorFunction, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod ) + : AnimatorBase( propertyOwner, animatorFunction, alphaFunction, timePeriod ), + mPropertyAccessor( property ) { // WARNING - this object is created in the event-thread // The scene-graph mPropertyOwner object cannot be observed here @@ -515,73 +656,100 @@ private: protected: - PropertyOwner* mPropertyOwner; PropertyAccessorType mPropertyAccessor; - AnimatorFunctionBase* mAnimatorFunction; - float mCurrentProgress; }; -} // namespace SceneGraph -/* - * AnimatorFunction base class. - * All update functions must inherit from AnimatorFunctionBase and overload the appropiate "()" operator + +/** + * An animator for a specific property type PropertyType. */ -struct AnimatorFunctionBase +template +class AnimatorTransformProperty : public AnimatorBase { - /** - * Constructor - */ - AnimatorFunctionBase(){} +public: - /* - * Virtual destructor (Intended as base class) + /** + * Construct a new property animator. + * @param[in] property The animatable property; only valid while the Animator is attached. + * @param[in] animatorFunction The function used to animate the property. + * @param[in] alphaFunction The alpha function to apply. + * @param[in] timePeriod The time period of this animation. + * @return A newly allocated animator. */ - virtual ~AnimatorFunctionBase(){} - - ///Stub "()" operators. - virtual bool operator()(float progress, const bool& property) + static AnimatorBase* New( const PropertyOwner& propertyOwner, + const PropertyBase& property, + AnimatorFunctionBase* animatorFunction, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod ) { - return property; - } - virtual float operator()(float progress, const int& property) - { - return property; + // The property was const in the actor-thread, but animators are used in the scene-graph thread. + return new AnimatorTransformProperty( const_cast( &propertyOwner ), + const_cast( &property ), + animatorFunction, + alphaFunction, + timePeriod ); } - virtual float operator()(float progress, const unsigned int& property) + /** + * Virtual destructor. + */ + virtual ~AnimatorTransformProperty() { - return property; } - virtual float operator()(float progress, const float& property) + /** + * @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) + */ + virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) override final { - return property; - } + const PropertyType& current = mPropertyAccessor.Get( bufferIndex ); - virtual Vector2 operator()(float progress, const Vector2& property) - { - return property; - } + // need to cast the return value in case property is integer + const PropertyType result = static_cast( (*mAnimatorFunction)( alpha, current ) ); - virtual Vector3 operator()(float progress, const Vector3& property) - { - return property; + if ( bake ) + { + mPropertyAccessor.Bake( bufferIndex, result ); + } + else + { + mPropertyAccessor.Set( bufferIndex, result ); + } } - virtual Vector4 operator()(float progress, const Vector4& property) - { - return property; - } +private: - virtual Quaternion operator()(float progress, const Quaternion& property) + /** + * Private constructor; see also Animator::New(). + */ + AnimatorTransformProperty( PropertyOwner* propertyOwner, + PropertyBase* property, + AnimatorFunctionBase* animatorFunction, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod ) + : AnimatorBase( propertyOwner, animatorFunction, alphaFunction, timePeriod ), + mPropertyAccessor( property ) { - return property; + // WARNING - this object is created in the event-thread + // The scene-graph mPropertyOwner object cannot be observed here } + + // Undefined + AnimatorTransformProperty() = delete; + AnimatorTransformProperty( const AnimatorTransformProperty& ) = delete; + AnimatorTransformProperty& operator=( const AnimatorTransformProperty& ) = delete; + +protected: + + PropertyAccessorType mPropertyAccessor; + }; +} // namespace SceneGraph + // Update functions struct AnimateByInteger : public AnimatorFunctionBase @@ -591,12 +759,14 @@ struct AnimateByInteger : public AnimatorFunctionBase { } - float operator()(float alpha, const int& property) + using AnimatorFunctionBase::operator(); + float operator()(float alpha, const int32_t& property) { - return int(property + mRelative * alpha + 0.5f ); + // integers need to be correctly rounded + return roundf(static_cast( property ) + static_cast( mRelative ) * alpha ); } - int mRelative; + int32_t mRelative; }; struct AnimateToInteger : public AnimatorFunctionBase @@ -606,12 +776,14 @@ struct AnimateToInteger : public AnimatorFunctionBase { } - float operator()(float alpha, const int& property) + using AnimatorFunctionBase::operator(); + float operator()(float alpha, const int32_t& property) { - return int(property + ((mTarget - property) * alpha) + 0.5f); + // integers need to be correctly rounded + return roundf(static_cast( property ) + (static_cast(mTarget - property) * alpha) ); } - int mTarget; + int32_t mTarget; }; struct AnimateByFloat : public AnimatorFunctionBase @@ -621,6 +793,7 @@ struct AnimateByFloat : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); float operator()(float alpha, const float& property) { return float(property + mRelative * alpha); @@ -636,6 +809,7 @@ struct AnimateToFloat : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); float operator()(float alpha, const float& property) { return float(property + ((mTarget - property) * alpha)); @@ -651,6 +825,7 @@ struct AnimateByVector2 : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector2 operator()(float alpha, const Vector2& property) { return Vector2(property + mRelative * alpha); @@ -666,6 +841,7 @@ struct AnimateToVector2 : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector2 operator()(float alpha, const Vector2& property) { return Vector2(property + ((mTarget - property) * alpha)); @@ -681,6 +857,7 @@ struct AnimateByVector3 : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector3 operator()(float alpha, const Vector3& property) { return Vector3(property + mRelative * alpha); @@ -696,6 +873,7 @@ struct AnimateToVector3 : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector3 operator()(float alpha, const Vector3& property) { return Vector3(property + ((mTarget - property) * alpha)); @@ -711,6 +889,7 @@ struct AnimateByVector4 : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector4 operator()(float alpha, const Vector4& property) { return Vector4(property + mRelative * alpha); @@ -726,6 +905,7 @@ struct AnimateToVector4 : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector4 operator()(float alpha, const Vector4& property) { return Vector4(property + ((mTarget - property) * alpha)); @@ -741,6 +921,7 @@ struct AnimateByOpacity : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector4 operator()(float alpha, const Vector4& property) { Vector4 result(property); @@ -759,6 +940,7 @@ struct AnimateToOpacity : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector4 operator()(float alpha, const Vector4& property) { Vector4 result(property); @@ -777,6 +959,7 @@ struct AnimateByBoolean : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); bool operator()(float alpha, const bool& property) { // Alpha is not useful here, just keeping to the same template as other update functors @@ -793,6 +976,7 @@ struct AnimateToBoolean : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); bool operator()(float alpha, const bool& property) { // Alpha is not useful here, just keeping to the same template as other update functors @@ -810,6 +994,7 @@ struct RotateByAngleAxis : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Quaternion operator()(float alpha, const Quaternion& rotation) { if (alpha > 0.0f) @@ -831,6 +1016,7 @@ struct RotateToQuaternion : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Quaternion operator()(float alpha, const Quaternion& rotation) { return Quaternion::Slerp(rotation, mTarget, alpha); @@ -847,6 +1033,7 @@ struct KeyFrameBooleanFunctor : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); bool operator()(float progress, const bool& property) { if(mKeyFrames->IsActive(progress)) @@ -866,13 +1053,14 @@ struct KeyFrameIntegerFunctor : public AnimatorFunctionBase { } - float operator()(float progress, const int& property) + using AnimatorFunctionBase::operator(); + float operator()(float progress, const int32_t& property) { if(mKeyFrames->IsActive(progress)) { - return mKeyFrames->GetValue(progress, mInterpolation); + return static_cast( mKeyFrames->GetValue(progress, mInterpolation) ); } - return property; + return static_cast( property ); } KeyFrameIntegerPtr mKeyFrames; @@ -886,6 +1074,7 @@ struct KeyFrameNumberFunctor : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); float operator()(float progress, const float& property) { if(mKeyFrames->IsActive(progress)) @@ -906,6 +1095,7 @@ struct KeyFrameVector2Functor : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector2 operator()(float progress, const Vector2& property) { if(mKeyFrames->IsActive(progress)) @@ -927,6 +1117,7 @@ struct KeyFrameVector3Functor : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector3 operator()(float progress, const Vector3& property) { if(mKeyFrames->IsActive(progress)) @@ -947,6 +1138,7 @@ struct KeyFrameVector4Functor : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector4 operator()(float progress, const Vector4& property) { if(mKeyFrames->IsActive(progress)) @@ -967,6 +1159,7 @@ struct KeyFrameQuaternionFunctor : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Quaternion operator()(float progress, const Quaternion& property) { if(mKeyFrames->IsActive(progress)) @@ -986,9 +1179,12 @@ struct PathPositionFunctor : public AnimatorFunctionBase { } + using AnimatorFunctionBase::operator(); Vector3 operator()(float progress, const Vector3& property) { - return mPath->SamplePosition(progress ); + Vector3 position(property); + static_cast( mPath->SamplePosition(progress, position) ); + return position; } PathPtr mPath; @@ -1003,19 +1199,26 @@ struct PathRotationFunctor : public AnimatorFunctionBase mForward.Normalize(); } + using AnimatorFunctionBase::operator(); Quaternion operator()(float progress, const Quaternion& property) { - Vector3 tangent( mPath->SampleTangent(progress) ); - return Quaternion( mForward, tangent ); + Vector3 tangent; + if( mPath->SampleTangent(progress, tangent) ) + { + return Quaternion( mForward, tangent ); + } + else + { + return property; + } } PathPtr mPath; Vector3 mForward; }; - } // namespace Internal } // namespace Dali -#endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__ +#endif // DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H