1 #ifndef __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__
2 #define __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__
5 * Copyright (c) 2018 Samsung Electronics Co., Ltd.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
22 #include <dali/public-api/animation/alpha-function.h>
23 #include <dali/public-api/animation/animation.h>
24 #include <dali/public-api/animation/time-period.h>
25 #include <dali/public-api/common/constants.h>
26 #include <dali/public-api/common/dali-common.h>
27 #include <dali/public-api/math/quaternion.h>
28 #include <dali/public-api/math/radian.h>
29 #include <dali/devel-api/common/owner-container.h>
30 #include <dali/internal/event/animation/key-frames-impl.h>
31 #include <dali/internal/event/animation/path-impl.h>
32 #include <dali/internal/update/nodes/node.h>
33 #include <dali/internal/update/common/property-base.h>
34 #include <dali/internal/update/animation/property-accessor.h>
35 #include <dali/integration-api/debug.h>
43 typedef Dali::Animation::Interpolation Interpolation;
45 struct AnimatorFunctionBase;
52 typedef OwnerContainer< AnimatorBase* > AnimatorContainer;
54 typedef AnimatorContainer::Iterator AnimatorIter;
55 typedef AnimatorContainer::ConstIterator AnimatorConstIter;
58 * An abstract base class for Animators, which can be added to scene graph animations.
59 * Each animator changes a single property of an object in the scene graph.
65 typedef float (*AlphaFunc)(float progress); ///< Definition of an alpha function
68 * Observer to determine when the animator is no longer present
70 class LifecycleObserver
74 * Called shortly before the animator is destroyed.
76 virtual void ObjectDestroyed() = 0;
80 * Virtual destructor, no deletion through this interface
82 virtual ~LifecycleObserver() = default;
90 : mLifecycleObserver(nullptr),
91 mDurationSeconds(1.0f),
92 mIntervalDelaySeconds(0.0f),
95 mAlphaFunction(AlphaFunction::DEFAULT),
96 mDisconnectAction(Dali::Animation::BakeFinal),
99 mConnectedToSceneGraph(false),
100 mAutoReverseEnabled( false )
105 * Virtual destructor.
107 virtual ~AnimatorBase()
109 if( mLifecycleObserver != nullptr )
111 mLifecycleObserver->ObjectDestroyed();
115 void AddLifecycleObserver( LifecycleObserver& observer )
117 mLifecycleObserver = &observer;
120 void RemoveLifecycleObserver( LifecycleObserver& observer )
122 mLifecycleObserver = nullptr;
126 * Called when Animator is added to the scene-graph in update-thread.
128 virtual void ConnectToSceneGraph() = 0;
131 * Set the duration of the animator.
132 * @pre durationSeconds must be zero or greater; zero is useful when animating boolean values.
133 * @param [in] seconds Duration in seconds.
135 void SetDuration(float seconds)
137 DALI_ASSERT_DEBUG(seconds >= 0.0f);
139 mDurationSeconds = seconds;
143 * Retrieve the duration of the animator.
144 * @return The duration in seconds.
146 float GetDuration() const
148 return mDurationSeconds;
151 void SetSpeedFactor( float factor )
153 mSpeedFactor = factor;
156 void SetLoopCount(int32_t loopCount)
158 mLoopCount = loopCount;
161 float SetProgress( float progress )
165 if( mAutoReverseEnabled )
167 if( mSpeedFactor > 0.0f )
169 value = 1.0f - 2.0f * std::abs( progress - 0.5f );
172 else if( mSpeedFactor < 0.0f )
174 value = 2.0f * std::abs( progress - 0.5f );
186 * Set the delay before the animator should take effect.
187 * The default is zero i.e. no delay.
188 * @param [in] seconds The delay in seconds.
190 void SetIntervalDelay(float seconds)
192 mIntervalDelaySeconds = seconds;
196 * Retrieve the delay before the animator should take effect.
197 * @return The delay in seconds.
199 float GetIntervalDelay() const
201 return mIntervalDelaySeconds;
205 * Set the alpha function for an animator.
206 * @param [in] alphaFunc The alpha function to apply to the animation progress.
208 void SetAlphaFunction(const AlphaFunction& alphaFunction)
210 mAlphaFunction = alphaFunction;
214 * Retrieve the alpha function of an animator.
215 * @return The function.
217 AlphaFunction GetAlphaFunction() const
219 return mAlphaFunction;
223 * Applies the alpha function to the specified progress
224 * @param[in] Current progress
225 * @return The progress after the alpha function has been aplied
227 float ApplyAlphaFunction( float progress ) const
229 float result = progress;
231 AlphaFunction::Mode alphaFunctionMode( mAlphaFunction.GetMode() );
232 if( alphaFunctionMode == AlphaFunction::BUILTIN_FUNCTION )
234 switch(mAlphaFunction.GetBuiltinFunction())
236 case AlphaFunction::DEFAULT:
237 case AlphaFunction::LINEAR:
241 case AlphaFunction::REVERSE:
243 result = 1.0f-progress;
246 case AlphaFunction::EASE_IN_SQUARE:
248 result = progress * progress;
251 case AlphaFunction::EASE_OUT_SQUARE:
253 result = 1.0f - (1.0f-progress) * (1.0f-progress);
256 case AlphaFunction::EASE_IN:
258 result = progress * progress * progress;
261 case AlphaFunction::EASE_OUT:
263 result = (progress-1.0f) * (progress-1.0f) * (progress-1.0f) + 1.0f;
266 case AlphaFunction::EASE_IN_OUT:
268 result = progress*progress*(3.0f-2.0f*progress);
271 case AlphaFunction::EASE_IN_SINE:
273 result = -1.0f * cosf(progress * Math::PI_2) + 1.0f;
276 case AlphaFunction::EASE_OUT_SINE:
278 result = sinf(progress * Math::PI_2);
281 case AlphaFunction::EASE_IN_OUT_SINE:
283 result = -0.5f * (cosf(Math::PI * progress) - 1.0f);
286 case AlphaFunction::BOUNCE:
288 result = sinf(progress * Math::PI);
291 case AlphaFunction::SIN:
293 result = 0.5f - cosf(progress * 2.0f * Math::PI) * 0.5f;
296 case AlphaFunction::EASE_OUT_BACK:
298 const float sqrt2 = 1.70158f;
300 result = 1.0f + progress * progress * ( ( sqrt2 + 1.0f ) * progress + sqrt2 );
303 case AlphaFunction::COUNT:
309 else if( alphaFunctionMode == AlphaFunction::CUSTOM_FUNCTION )
311 AlphaFunctionPrototype customFunction = mAlphaFunction.GetCustomFunction();
314 result = customFunction(progress);
319 //If progress is very close to 0 or very close to 1 we don't need to evaluate the curve as the result will
320 //be almost 0 or almost 1 respectively
321 if( ( progress > Math::MACHINE_EPSILON_1 ) && ((1.0f - progress) > Math::MACHINE_EPSILON_1) )
323 Dali::Vector4 controlPoints = mAlphaFunction.GetBezierControlPoints();
325 static const float tolerance = 0.001f; //10 iteration max
327 //Perform a binary search on the curve
328 float lowerBound(0.0f);
329 float upperBound(1.0f);
330 float currentT(0.5f);
331 float currentX = EvaluateCubicBezier( controlPoints.x, controlPoints.z, currentT);
332 while( fabsf( progress - currentX ) > tolerance )
334 if( progress > currentX )
336 lowerBound = currentT;
340 upperBound = currentT;
342 currentT = (upperBound+lowerBound)*0.5f;
343 currentX = EvaluateCubicBezier( controlPoints.x, controlPoints.z, currentT);
345 result = EvaluateCubicBezier( controlPoints.y, controlPoints.w, currentT);
353 * Whether to bake the animation if attached property owner is disconnected.
354 * Property is only baked if the animator is active.
355 * @param [in] action The disconnect action.
357 void SetDisconnectAction( Dali::Animation::EndAction action )
359 mDisconnectAction = action;
363 * Retrieve the disconnect action of an animator.
364 * @return The disconnect action.
366 Dali::Animation::EndAction GetDisconnectAction() const
368 return mDisconnectAction;
372 * Whether the animator is active or not.
373 * @param [in] active The new active state.
374 * @post When the animator becomes active, it applies the disconnect-action if the property owner is then disconnected.
375 * @note When the property owner is disconnected, the active state is set to false.
377 void SetActive( bool active )
383 * Retrieve whether the animator has been set to active or not.
384 * @return The active state.
386 bool GetActive() const
392 * Retrive wheter the animator's target object is valid and on the stage.
393 * @return The enabled state.
395 bool IsEnabled() const
401 * @brief Sets the looping mode.
402 * @param[in] loopingMode True when the looping mode is AUTO_REVERSE
404 void SetLoopingMode( bool loopingMode )
406 mAutoReverseEnabled = loopingMode;
410 * Returns wheter the target object of the animator is still valid
411 * or has been destroyed.
412 * @return True if animator is orphan, false otherwise *
413 * @note The SceneGraph::Animation will delete any orphan animator in its Update method.
415 virtual bool Orphan() = 0;
418 * Update the scene object attached to the animator.
419 * @param[in] bufferIndex The buffer to animate.
420 * @param[in] progress A value from 0 to 1, where 0 is the start of the animation, and 1 is the end point.
421 * @param[in] bake Bake.
423 virtual void Update(BufferIndex bufferIndex, float progress, bool bake) = 0;
428 * Helper function to evaluate a cubic bezier curve assuming first point is at 0.0 and last point is at 1.0
429 * @param[in] p0 First control point of the bezier curve
430 * @param[in] p1 Second control point of the bezier curve
431 * @param[in] t A floating point value between 0.0 and 1.0
432 * @return Value of the curve at progress t
434 inline float EvaluateCubicBezier( float p0, float p1, float t ) const
437 return 3.0f*(1.0f-t)*(1.0f-t)*t*p0 + 3.0f*(1.0f-t)*tSquare*p1 + tSquare*t;
440 LifecycleObserver* mLifecycleObserver;
441 float mDurationSeconds;
442 float mIntervalDelaySeconds;
447 AlphaFunction mAlphaFunction;
449 Dali::Animation::EndAction mDisconnectAction; ///< EndAction to apply when target object gets disconnected from the stage.
450 bool mActive:1; ///< Animator is "active" while it's running.
451 bool mEnabled:1; ///< Animator is "enabled" while its target object is valid and on the stage.
452 bool mConnectedToSceneGraph:1; ///< True if ConnectToSceneGraph() has been called in update-thread.
453 bool mAutoReverseEnabled:1;
457 * An animator for a specific property type PropertyType.
459 template < typename PropertyType, typename PropertyAccessorType >
460 class Animator : public AnimatorBase, public PropertyOwner::Observer
465 * Construct a new property animator.
466 * @param[in] property The animatable property; only valid while the Animator is attached.
467 * @param[in] animatorFunction The function used to animate the property.
468 * @param[in] alphaFunction The alpha function to apply.
469 * @param[in] timePeriod The time period of this animation.
470 * @return A newly allocated animator.
472 static AnimatorBase* New( const PropertyOwner& propertyOwner,
473 const PropertyBase& property,
474 AnimatorFunctionBase* animatorFunction,
475 AlphaFunction alphaFunction,
476 const TimePeriod& timePeriod )
478 typedef Animator< PropertyType, PropertyAccessorType > AnimatorType;
480 // The property was const in the actor-thread, but animators are used in the scene-graph thread.
481 AnimatorType* animator = new AnimatorType( const_cast<PropertyOwner*>( &propertyOwner ),
482 const_cast<PropertyBase*>( &property ),
485 animator->SetAlphaFunction( alphaFunction );
486 animator->SetIntervalDelay( timePeriod.delaySeconds );
487 animator->SetDuration( timePeriod.durationSeconds );
493 * Virtual destructor.
497 if (mPropertyOwner && mConnectedToSceneGraph)
499 mPropertyOwner->RemoveObserver(*this);
502 delete mAnimatorFunction;
506 * Called when Animator is added to the scene-graph in update-thread.
508 virtual void ConnectToSceneGraph()
510 mConnectedToSceneGraph = true;
511 mPropertyOwner->AddObserver(*this);
515 * Called when mPropertyOwner is connected to the scene graph.
517 virtual void PropertyOwnerConnected( PropertyOwner& owner )
523 * Called when mPropertyOwner is disconnected from the scene graph.
525 virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
527 // If we are active, then bake the value if required
528 if ( mActive && mDisconnectAction != Dali::Animation::Discard )
530 // Bake to target-value if BakeFinal, otherwise bake current value
531 Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true );
539 * Called shortly before mPropertyOwner is destroyed
541 virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
543 mPropertyOwner = NULL;
549 virtual void Update( BufferIndex bufferIndex, float progress, bool bake )
551 if( mLoopCount >= 0 )
553 // Update the progress value
554 progress = SetProgress( progress );
557 float alpha = ApplyAlphaFunction( progress );
559 const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
561 // need to cast the return value in case property is integer
562 const PropertyType result = static_cast<PropertyType>( (*mAnimatorFunction)( alpha, current ) );
565 mPropertyAccessor.Bake( bufferIndex, result );
569 mPropertyAccessor.Set( bufferIndex, result );
572 mCurrentProgress = progress;
578 virtual bool Orphan()
580 return (mPropertyOwner == NULL);
586 * Private constructor; see also Animator::New().
588 Animator( PropertyOwner* propertyOwner,
589 PropertyBase* property,
590 AnimatorFunctionBase* animatorFunction )
591 : mPropertyOwner( propertyOwner ),
592 mPropertyAccessor( property ),
593 mAnimatorFunction( animatorFunction ),
594 mCurrentProgress( 0.0f )
596 // WARNING - this object is created in the event-thread
597 // The scene-graph mPropertyOwner object cannot be observed here
601 Animator( const Animator& );
604 Animator& operator=( const Animator& );
608 PropertyOwner* mPropertyOwner;
609 PropertyAccessorType mPropertyAccessor;
611 AnimatorFunctionBase* mAnimatorFunction;
612 float mCurrentProgress;
618 * An animator for a specific property type PropertyType.
620 template <typename T, typename PropertyAccessorType>
621 class AnimatorTransformProperty : public AnimatorBase, public PropertyOwner::Observer
626 * Construct a new property animator.
627 * @param[in] property The animatable property; only valid while the Animator is attached.
628 * @param[in] animatorFunction The function used to animate the property.
629 * @param[in] alphaFunction The alpha function to apply.
630 * @param[in] timePeriod The time period of this animation.
631 * @return A newly allocated animator.
633 static AnimatorBase* New( const PropertyOwner& propertyOwner,
634 const PropertyBase& property,
635 AnimatorFunctionBase* animatorFunction,
636 AlphaFunction alphaFunction,
637 const TimePeriod& timePeriod )
640 // The property was const in the actor-thread, but animators are used in the scene-graph thread.
641 AnimatorTransformProperty* animator = new AnimatorTransformProperty( const_cast<PropertyOwner*>( &propertyOwner ),
642 const_cast<PropertyBase*>( &property ),
645 animator->SetAlphaFunction( alphaFunction );
646 animator->SetIntervalDelay( timePeriod.delaySeconds );
647 animator->SetDuration( timePeriod.durationSeconds );
653 * Virtual destructor.
655 virtual ~AnimatorTransformProperty()
657 if (mPropertyOwner && mConnectedToSceneGraph)
659 mPropertyOwner->RemoveObserver(*this);
662 delete mAnimatorFunction;
666 * Called when Animator is added to the scene-graph in update-thread.
668 virtual void ConnectToSceneGraph()
670 mConnectedToSceneGraph = true;
671 mPropertyOwner->AddObserver(*this);
675 * Called when mPropertyOwner is connected to the scene graph.
677 virtual void PropertyOwnerConnected( PropertyOwner& owner )
683 * Called when mPropertyOwner is disconnected from the scene graph.
685 virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
687 // If we are active, then bake the value if required
688 if ( mActive && mDisconnectAction != Dali::Animation::Discard )
690 // Bake to target-value if BakeFinal, otherwise bake current value
691 Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true );
699 * Called shortly before mPropertyOwner is destroyed
701 virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
703 mPropertyOwner = NULL;
709 virtual void Update( BufferIndex bufferIndex, float progress, bool bake )
711 if( mLoopCount >= 0 )
713 // Update the progress value
714 progress = SetProgress( progress );
717 float alpha = ApplyAlphaFunction( progress );
719 const T& current = mPropertyAccessor.Get( bufferIndex );
721 // need to cast the return value in case property is integer
722 T result = static_cast<T>( (*mAnimatorFunction)( alpha, current ) );
726 mPropertyAccessor.Bake( bufferIndex, result );
730 mPropertyAccessor.Set( bufferIndex, result );
733 mCurrentProgress = progress;
739 virtual bool Orphan()
741 return (mPropertyOwner == NULL);
747 * Private constructor; see also Animator::New().
749 AnimatorTransformProperty( PropertyOwner* propertyOwner,
750 PropertyBase* property,
751 AnimatorFunctionBase* animatorFunction )
752 : mPropertyOwner( propertyOwner ),
753 mPropertyAccessor( property ),
754 mAnimatorFunction( animatorFunction ),
755 mCurrentProgress( 0.0f )
757 // WARNING - this object is created in the event-thread
758 // The scene-graph mPropertyOwner object cannot be observed here
762 AnimatorTransformProperty( const AnimatorTransformProperty& );
765 AnimatorTransformProperty& operator=( const AnimatorTransformProperty& );
769 PropertyOwner* mPropertyOwner;
770 PropertyAccessorType mPropertyAccessor;
772 AnimatorFunctionBase* mAnimatorFunction;
773 float mCurrentProgress;
776 } // namespace SceneGraph
779 * AnimatorFunction base class.
780 * All update functions must inherit from AnimatorFunctionBase and overload the appropiate "()" operator
782 struct AnimatorFunctionBase
787 AnimatorFunctionBase(){}
790 * Virtual destructor (Intended as base class)
792 virtual ~AnimatorFunctionBase(){}
794 ///Stub "()" operators.
795 virtual bool operator()(float progress, const bool& property)
800 virtual float operator()(float progress, const int32_t& property)
802 return static_cast<float>( property );
805 virtual float operator()(float progress, const float& property)
810 virtual Vector2 operator()(float progress, const Vector2& property)
815 virtual Vector3 operator()(float progress, const Vector3& property)
820 virtual Vector4 operator()(float progress, const Vector4& property)
825 virtual Quaternion operator()(float progress, const Quaternion& property)
833 struct AnimateByInteger : public AnimatorFunctionBase
835 AnimateByInteger(const int& relativeValue)
836 : mRelative(relativeValue)
840 using AnimatorFunctionBase::operator();
841 float operator()(float alpha, const int32_t& property)
843 return truncf(static_cast<float>( property ) + static_cast<float>( mRelative ) * alpha + 0.5f );
849 struct AnimateToInteger : public AnimatorFunctionBase
851 AnimateToInteger(const int& targetValue)
852 : mTarget(targetValue)
856 using AnimatorFunctionBase::operator();
857 float operator()(float alpha, const int32_t& property)
859 return truncf(static_cast<float>( property ) + (static_cast<float>(mTarget - property) * alpha) + 0.5f);
865 struct AnimateByFloat : public AnimatorFunctionBase
867 AnimateByFloat(const float& relativeValue)
868 : mRelative(relativeValue)
872 using AnimatorFunctionBase::operator();
873 float operator()(float alpha, const float& property)
875 return float(property + mRelative * alpha);
881 struct AnimateToFloat : public AnimatorFunctionBase
883 AnimateToFloat(const float& targetValue)
884 : mTarget(targetValue)
888 using AnimatorFunctionBase::operator();
889 float operator()(float alpha, const float& property)
891 return float(property + ((mTarget - property) * alpha));
897 struct AnimateByVector2 : public AnimatorFunctionBase
899 AnimateByVector2(const Vector2& relativeValue)
900 : mRelative(relativeValue)
904 using AnimatorFunctionBase::operator();
905 Vector2 operator()(float alpha, const Vector2& property)
907 return Vector2(property + mRelative * alpha);
913 struct AnimateToVector2 : public AnimatorFunctionBase
915 AnimateToVector2(const Vector2& targetValue)
916 : mTarget(targetValue)
920 using AnimatorFunctionBase::operator();
921 Vector2 operator()(float alpha, const Vector2& property)
923 return Vector2(property + ((mTarget - property) * alpha));
929 struct AnimateByVector3 : public AnimatorFunctionBase
931 AnimateByVector3(const Vector3& relativeValue)
932 : mRelative(relativeValue)
936 using AnimatorFunctionBase::operator();
937 Vector3 operator()(float alpha, const Vector3& property)
939 return Vector3(property + mRelative * alpha);
945 struct AnimateToVector3 : public AnimatorFunctionBase
947 AnimateToVector3(const Vector3& targetValue)
948 : mTarget(targetValue)
952 using AnimatorFunctionBase::operator();
953 Vector3 operator()(float alpha, const Vector3& property)
955 return Vector3(property + ((mTarget - property) * alpha));
961 struct AnimateByVector4 : public AnimatorFunctionBase
963 AnimateByVector4(const Vector4& relativeValue)
964 : mRelative(relativeValue)
968 using AnimatorFunctionBase::operator();
969 Vector4 operator()(float alpha, const Vector4& property)
971 return Vector4(property + mRelative * alpha);
977 struct AnimateToVector4 : public AnimatorFunctionBase
979 AnimateToVector4(const Vector4& targetValue)
980 : mTarget(targetValue)
984 using AnimatorFunctionBase::operator();
985 Vector4 operator()(float alpha, const Vector4& property)
987 return Vector4(property + ((mTarget - property) * alpha));
993 struct AnimateByOpacity : public AnimatorFunctionBase
995 AnimateByOpacity(const float& relativeValue)
996 : mRelative(relativeValue)
1000 using AnimatorFunctionBase::operator();
1001 Vector4 operator()(float alpha, const Vector4& property)
1003 Vector4 result(property);
1004 result.a += mRelative * alpha;
1012 struct AnimateToOpacity : public AnimatorFunctionBase
1014 AnimateToOpacity(const float& targetValue)
1015 : mTarget(targetValue)
1019 using AnimatorFunctionBase::operator();
1020 Vector4 operator()(float alpha, const Vector4& property)
1022 Vector4 result(property);
1023 result.a = property.a + ((mTarget - property.a) * alpha);
1031 struct AnimateByBoolean : public AnimatorFunctionBase
1033 AnimateByBoolean(bool relativeValue)
1034 : mRelative(relativeValue)
1038 using AnimatorFunctionBase::operator();
1039 bool operator()(float alpha, const bool& property)
1041 // Alpha is not useful here, just keeping to the same template as other update functors
1042 return bool(alpha >= 1.0f ? (property || mRelative) : property);
1048 struct AnimateToBoolean : public AnimatorFunctionBase
1050 AnimateToBoolean(bool targetValue)
1051 : mTarget(targetValue)
1055 using AnimatorFunctionBase::operator();
1056 bool operator()(float alpha, const bool& property)
1058 // Alpha is not useful here, just keeping to the same template as other update functors
1059 return bool(alpha >= 1.0f ? mTarget : property);
1065 struct RotateByAngleAxis : public AnimatorFunctionBase
1067 RotateByAngleAxis(const Radian& angleRadians, const Vector3& axis)
1068 : mAngleRadians( angleRadians ),
1069 mAxis(axis.x, axis.y, axis.z)
1073 using AnimatorFunctionBase::operator();
1074 Quaternion operator()(float alpha, const Quaternion& rotation)
1078 return rotation * Quaternion(mAngleRadians * alpha, mAxis);
1084 Radian mAngleRadians;
1088 struct RotateToQuaternion : public AnimatorFunctionBase
1090 RotateToQuaternion(const Quaternion& targetValue)
1091 : mTarget(targetValue)
1095 using AnimatorFunctionBase::operator();
1096 Quaternion operator()(float alpha, const Quaternion& rotation)
1098 return Quaternion::Slerp(rotation, mTarget, alpha);
1105 struct KeyFrameBooleanFunctor : public AnimatorFunctionBase
1107 KeyFrameBooleanFunctor(KeyFrameBooleanPtr keyFrames)
1108 : mKeyFrames(keyFrames)
1112 using AnimatorFunctionBase::operator();
1113 bool operator()(float progress, const bool& property)
1115 if(mKeyFrames->IsActive(progress))
1117 return mKeyFrames->GetValue(progress, Dali::Animation::Linear);
1122 KeyFrameBooleanPtr mKeyFrames;
1125 struct KeyFrameIntegerFunctor : public AnimatorFunctionBase
1127 KeyFrameIntegerFunctor(KeyFrameIntegerPtr keyFrames, Interpolation interpolation)
1128 : mKeyFrames(keyFrames),mInterpolation(interpolation)
1132 using AnimatorFunctionBase::operator();
1133 float operator()(float progress, const int32_t& property)
1135 if(mKeyFrames->IsActive(progress))
1137 return static_cast<float>( mKeyFrames->GetValue(progress, mInterpolation) );
1139 return static_cast<float>( property );
1142 KeyFrameIntegerPtr mKeyFrames;
1143 Interpolation mInterpolation;
1146 struct KeyFrameNumberFunctor : public AnimatorFunctionBase
1148 KeyFrameNumberFunctor(KeyFrameNumberPtr keyFrames, Interpolation interpolation)
1149 : mKeyFrames(keyFrames),mInterpolation(interpolation)
1153 using AnimatorFunctionBase::operator();
1154 float operator()(float progress, const float& property)
1156 if(mKeyFrames->IsActive(progress))
1158 return mKeyFrames->GetValue(progress, mInterpolation);
1163 KeyFrameNumberPtr mKeyFrames;
1164 Interpolation mInterpolation;
1167 struct KeyFrameVector2Functor : public AnimatorFunctionBase
1169 KeyFrameVector2Functor(KeyFrameVector2Ptr keyFrames, Interpolation interpolation)
1170 : mKeyFrames(keyFrames),mInterpolation(interpolation)
1174 using AnimatorFunctionBase::operator();
1175 Vector2 operator()(float progress, const Vector2& property)
1177 if(mKeyFrames->IsActive(progress))
1179 return mKeyFrames->GetValue(progress, mInterpolation);
1184 KeyFrameVector2Ptr mKeyFrames;
1185 Interpolation mInterpolation;
1189 struct KeyFrameVector3Functor : public AnimatorFunctionBase
1191 KeyFrameVector3Functor(KeyFrameVector3Ptr keyFrames, Interpolation interpolation)
1192 : mKeyFrames(keyFrames),mInterpolation(interpolation)
1196 using AnimatorFunctionBase::operator();
1197 Vector3 operator()(float progress, const Vector3& property)
1199 if(mKeyFrames->IsActive(progress))
1201 return mKeyFrames->GetValue(progress, mInterpolation);
1206 KeyFrameVector3Ptr mKeyFrames;
1207 Interpolation mInterpolation;
1210 struct KeyFrameVector4Functor : public AnimatorFunctionBase
1212 KeyFrameVector4Functor(KeyFrameVector4Ptr keyFrames, Interpolation interpolation)
1213 : mKeyFrames(keyFrames),mInterpolation(interpolation)
1217 using AnimatorFunctionBase::operator();
1218 Vector4 operator()(float progress, const Vector4& property)
1220 if(mKeyFrames->IsActive(progress))
1222 return mKeyFrames->GetValue(progress, mInterpolation);
1227 KeyFrameVector4Ptr mKeyFrames;
1228 Interpolation mInterpolation;
1231 struct KeyFrameQuaternionFunctor : public AnimatorFunctionBase
1233 KeyFrameQuaternionFunctor(KeyFrameQuaternionPtr keyFrames)
1234 : mKeyFrames(keyFrames)
1238 using AnimatorFunctionBase::operator();
1239 Quaternion operator()(float progress, const Quaternion& property)
1241 if(mKeyFrames->IsActive(progress))
1243 return mKeyFrames->GetValue(progress, Dali::Animation::Linear);
1248 KeyFrameQuaternionPtr mKeyFrames;
1251 struct PathPositionFunctor : public AnimatorFunctionBase
1253 PathPositionFunctor( PathPtr path )
1258 using AnimatorFunctionBase::operator();
1259 Vector3 operator()(float progress, const Vector3& property)
1261 Vector3 position(property);
1262 static_cast<void>( mPath->SamplePosition(progress, position) );
1269 struct PathRotationFunctor : public AnimatorFunctionBase
1271 PathRotationFunctor( PathPtr path, const Vector3& forward )
1275 mForward.Normalize();
1278 using AnimatorFunctionBase::operator();
1279 Quaternion operator()(float progress, const Quaternion& property)
1282 if( mPath->SampleTangent(progress, tangent) )
1284 return Quaternion( mForward, tangent );
1296 } // namespace Internal
1300 #endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__