1 #ifndef __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__
2 #define __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__
5 * Copyright (c) 2014 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/internal/common/owner-container.h>
23 #include <dali/internal/event/animation/key-frames-impl.h>
24 #include <dali/internal/event/animation/path-impl.h>
25 #include <dali/internal/update/nodes/node.h>
26 #include <dali/internal/update/common/property-base.h>
27 #include <dali/public-api/animation/alpha-function.h>
28 #include <dali/public-api/animation/animation.h>
29 #include <dali/public-api/animation/time-period.h>
30 #include <dali/public-api/common/constants.h>
31 #include <dali/public-api/common/dali-common.h>
32 #include <dali/public-api/math/quaternion.h>
33 #include <dali/public-api/math/radian.h>
41 typedef Dali::Animation::Interpolation Interpolation;
43 struct AnimatorFunctionBase;
50 typedef OwnerContainer< AnimatorBase* > AnimatorContainer;
52 typedef AnimatorContainer::Iterator AnimatorIter;
53 typedef AnimatorContainer::ConstIterator AnimatorConstIter;
56 * An abstract base class for Animators, which can be added to scene graph animations.
57 * Each animator changes a single property of an object in the scene graph.
63 typedef float (*AlphaFunc)(float progress); ///< Definition of an alpha function
69 : mDurationSeconds(1.0f),
70 mInitialDelaySeconds(0.0f),
71 mAlphaFunction(AlphaFunction::DEFAULT),
72 mDisconnectAction(Dali::Animation::BakeFinal),
75 mConnectedToSceneGraph(false)
82 virtual ~AnimatorBase()
87 * Called when Animator is added to the scene-graph in update-thread.
89 virtual void ConnectToSceneGraph() = 0;
92 * Set the duration of the animator.
93 * @pre durationSeconds must be zero or greater; zero is useful when animating boolean values.
94 * @param [in] seconds Duration in seconds.
96 void SetDuration(float seconds)
98 DALI_ASSERT_DEBUG(seconds >= 0.0f);
100 mDurationSeconds = seconds;
104 * Retrieve the duration of the animator.
105 * @return The duration in seconds.
109 return mDurationSeconds;
113 * Set the delay before the animator should take effect.
114 * The default is zero i.e. no delay.
115 * @param [in] seconds The delay in seconds.
117 void SetInitialDelay(float seconds)
119 mInitialDelaySeconds = seconds;
123 * Retrieve the initial delay of the animator.
124 * @return The delay in seconds.
126 float GetInitialDelay()
128 return mInitialDelaySeconds;
132 * Set the alpha function for an animator.
133 * @param [in] alphaFunc The alpha function to apply to the animation progress.
135 void SetAlphaFunction(const AlphaFunction& alphaFunction)
137 mAlphaFunction = alphaFunction;
141 * Retrieve the alpha function of an animator.
142 * @return The function.
144 AlphaFunction GetAlphaFunction() const
146 return mAlphaFunction;
150 * Applies the alpha function to the specified progress
151 * @param[in] Current progress
152 * @return The progress after the alpha function has been aplied
154 float ApplyAlphaFunction( float progress ) const
156 float result = progress;
158 AlphaFunction::Mode alphaFunctionMode( mAlphaFunction.GetMode() );
159 if( alphaFunctionMode == AlphaFunction::BUILTIN_FUNCTION )
161 switch(mAlphaFunction.GetBuiltinFunction())
163 case AlphaFunction::DEFAULT:
164 case AlphaFunction::LINEAR:
168 case AlphaFunction::REVERSE:
170 result = 1.0f-progress;
173 case AlphaFunction::EASE_IN_SQUARE:
175 result = progress * progress;
178 case AlphaFunction::EASE_OUT_SQUARE:
180 result = 1.0f - (1.0f-progress) * (1.0f-progress);
183 case AlphaFunction::EASE_IN:
185 result = progress * progress * progress;
188 case AlphaFunction::EASE_OUT:
190 result = (progress-1.0f) * (progress-1.0f) * (progress-1.0f) + 1.0f;
193 case AlphaFunction::EASE_IN_OUT:
195 result = progress*progress*(3.0f-2.0f*progress);
198 case AlphaFunction::EASE_IN_SINE:
200 result = -1.0f * cosf(progress * Math::PI_2) + 1.0f;
203 case AlphaFunction::EASE_OUT_SINE:
205 result = sinf(progress * Math::PI_2);
208 case AlphaFunction::EASE_IN_OUT_SINE:
210 result = -0.5f * (cosf(Math::PI * progress) - 1.0f);
213 case AlphaFunction::BOUNCE:
215 result = sinf(progress * Math::PI);
218 case AlphaFunction::SIN:
220 result = 0.5f - cosf(progress * 2.0f * Math::PI) * 0.5f;
223 case AlphaFunction::EASE_OUT_BACK:
225 const float sqrt2 = 1.70158f;
227 result = 1.0f + progress * progress * ( ( sqrt2 + 1.0f ) * progress + sqrt2 );
230 case AlphaFunction::COUNT:
236 else if( alphaFunctionMode == AlphaFunction::CUSTOM_FUNCTION )
238 AlphaFunctionPrototype customFunction = mAlphaFunction.GetCustomFunction();
241 result = customFunction(progress);
246 //If progress is very close to 0 or very close to 1 we don't need to evaluate the curve as the result will
247 //be almost 0 or almost 1 respectively
248 if( ( progress > Math::MACHINE_EPSILON_1 ) && ((1.0f - progress) > Math::MACHINE_EPSILON_1) )
250 Dali::Vector4 controlPoints = mAlphaFunction.GetBezierControlPoints();
252 static const float tolerance = 0.001f; //10 iteration max
254 //Perform a binary search on the curve
255 float lowerBound(0.0f);
256 float upperBound(1.0f);
257 float currentT(0.5f);
258 float currentX = EvaluateCubicBezier( controlPoints.x, controlPoints.z, currentT);
259 while( fabs( progress - currentX ) > tolerance )
261 if( progress > currentX )
263 lowerBound = currentT;
267 upperBound = currentT;
269 currentT = (upperBound+lowerBound)*0.5f;
270 currentX = EvaluateCubicBezier( controlPoints.x, controlPoints.z, currentT);
272 result = EvaluateCubicBezier( controlPoints.y, controlPoints.w, currentT);
280 * Whether to bake the animation if attached property owner is disconnected.
281 * Property is only baked if the animator is active.
282 * @param [in] action The disconnect action.
284 void SetDisconnectAction( Dali::Animation::EndAction action )
286 mDisconnectAction = action;
290 * Retrieve the disconnect action of an animator.
291 * @return The disconnect action.
293 Dali::Animation::EndAction GetDisconnectAction() const
295 return mDisconnectAction;
299 * Whether the animator is active or not.
300 * @param [in] active The new active state.
301 * @post When the animator becomes active, it applies the disconnect-action if the property owner is then disconnected.
302 * @note When the property owner is disconnected, the active state is set to false.
304 void SetActive( bool active )
310 * Retrieve whether the animator has been set to active or not.
311 * @return The active state.
313 bool GetActive() const
319 * Retrive wheter the animator's target object is valid and on the stage.
320 * @return The enabled state.
322 bool IsEnabled() const
327 * Returns wheter the target object of the animator is still valid
328 * or has been destroyed.
329 * @return True if animator is orphan, false otherwise *
330 * @note The SceneGraph::Animation will delete any orphan animator in its Update method.
332 virtual bool Orphan() = 0;
335 * Update the scene object attached to the animator.
336 * @param[in] bufferIndex The buffer to animate.
337 * @param[in] progress A value from 0 to 1, where 0 is the start of the animation, and 1 is the end point.
338 * @param[in] bake Bake.
340 virtual void Update(BufferIndex bufferIndex, float progress, bool bake) = 0;
345 * Helper function to evaluate a cubic bezier curve assuming first point is at 0.0 and last point is at 1.0
346 * @param[in] p0 First control point of the bezier curve
347 * @param[in] p1 Second control point of the bezier curve
348 * @param[in] t A floating point value between 0.0 and 1.0
349 * @return Value of the curve at progress t
351 inline float EvaluateCubicBezier( float p0, float p1, float t ) const
354 return 3.0f*(1.0f-t)*(1.0f-t)*t*p0 + 3.0f*(1.0f-t)*tSquare*p1 + tSquare*t;
357 float mDurationSeconds;
358 float mInitialDelaySeconds;
360 AlphaFunction mAlphaFunction;
362 Dali::Animation::EndAction mDisconnectAction; ///< EndAction to apply when target object gets disconnected from the stage.
363 bool mActive:1; ///< Animator is "active" while it's running.
364 bool mEnabled:1; ///< Animator is "enabled" while its target object is valid and on the stage.
365 bool mConnectedToSceneGraph:1; ///< True if ConnectToSceneGraph() has been called in update-thread.
369 * An animator for a specific property type PropertyType.
371 template < typename PropertyType, typename PropertyAccessorType >
372 class Animator : public AnimatorBase, public PropertyOwner::Observer
377 * Construct a new property animator.
378 * @param[in] property The animatable property; only valid while the Animator is attached.
379 * @param[in] animatorFunction The function used to animate the property.
380 * @param[in] alphaFunction The alpha function to apply.
381 * @param[in] timePeriod The time period of this animation.
382 * @return A newly allocated animator.
384 static AnimatorBase* New( const PropertyOwner& propertyOwner,
385 const PropertyBase& property,
386 AnimatorFunctionBase* animatorFunction,
387 AlphaFunction alphaFunction,
388 const TimePeriod& timePeriod )
390 typedef Animator< PropertyType, PropertyAccessorType > AnimatorType;
392 // The property was const in the actor-thread, but animators are used in the scene-graph thread.
393 AnimatorType* animator = new AnimatorType( const_cast<PropertyOwner*>( &propertyOwner ),
394 const_cast<PropertyBase*>( &property ),
397 animator->SetAlphaFunction( alphaFunction );
398 animator->SetInitialDelay( timePeriod.delaySeconds );
399 animator->SetDuration( timePeriod.durationSeconds );
405 * Virtual destructor.
409 if (mPropertyOwner && mConnectedToSceneGraph)
411 mPropertyOwner->RemoveObserver(*this);
414 if( mAnimatorFunction )
416 delete mAnimatorFunction;
421 * Called when Animator is added to the scene-graph in update-thread.
423 virtual void ConnectToSceneGraph()
425 mConnectedToSceneGraph = true;
426 mPropertyOwner->AddObserver(*this);
430 * Called when mPropertyOwner is connected to the scene graph.
432 virtual void PropertyOwnerConnected( PropertyOwner& owner )
438 * Called when mPropertyOwner is disconnected from the scene graph.
440 virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
442 // If we are active, then bake the value if required
443 if ( mActive && mDisconnectAction != Dali::Animation::Discard )
445 // Bake to target-value if BakeFinal, otherwise bake current value
446 Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true );
454 * Called shortly before mPropertyOwner is destroyed
456 virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
458 mPropertyOwner = NULL;
459 mPropertyAccessor.Reset();
466 virtual void Update( BufferIndex bufferIndex, float progress, bool bake )
468 float alpha = ApplyAlphaFunction(progress);
470 const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
472 const PropertyType result = (*mAnimatorFunction)( alpha, current );
475 mPropertyAccessor.Bake( bufferIndex, result );
479 mPropertyAccessor.Set( bufferIndex, result );
482 mCurrentProgress = progress;
488 virtual bool Orphan()
490 return (mPropertyOwner == NULL);
496 * Private constructor; see also Animator::New().
498 Animator( PropertyOwner* propertyOwner,
499 PropertyBase* property,
500 AnimatorFunctionBase* animatorFunction )
501 : mPropertyOwner( propertyOwner ),
502 mPropertyAccessor( property ),
503 mAnimatorFunction( animatorFunction ),
504 mCurrentProgress( 0.0f )
506 // WARNING - this object is created in the event-thread
507 // The scene-graph mPropertyOwner object cannot be observed here
511 Animator( const Animator& );
514 Animator& operator=( const Animator& );
518 PropertyOwner* mPropertyOwner;
519 PropertyAccessorType mPropertyAccessor;
521 AnimatorFunctionBase* mAnimatorFunction;
522 float mCurrentProgress;
525 } // namespace SceneGraph
528 * AnimatorFunction base class.
529 * All update functions must inherit from AnimatorFunctionBase and overload the appropiate "()" operator
531 struct AnimatorFunctionBase
536 AnimatorFunctionBase(){}
539 * Virtual destructor (Intended as base class)
541 virtual ~AnimatorFunctionBase(){}
543 ///Stub "()" operators.
544 virtual bool operator()(float progress, const bool& property)
549 virtual float operator()(float progress, const int& property)
554 virtual float operator()(float progress, const unsigned int& property)
559 virtual float operator()(float progress, const float& property)
564 virtual Vector2 operator()(float progress, const Vector2& property)
569 virtual Vector3 operator()(float progress, const Vector3& property)
574 virtual Vector4 operator()(float progress, const Vector4& property)
579 virtual Quaternion operator()(float progress, const Quaternion& property)
587 struct AnimateByInteger : public AnimatorFunctionBase
589 AnimateByInteger(const int& relativeValue)
590 : mRelative(relativeValue)
594 float operator()(float alpha, const int& property)
596 return int(property + mRelative * alpha + 0.5f );
602 struct AnimateToInteger : public AnimatorFunctionBase
604 AnimateToInteger(const int& targetValue)
605 : mTarget(targetValue)
609 float operator()(float alpha, const int& property)
611 return int(property + ((mTarget - property) * alpha) + 0.5f);
617 struct AnimateByFloat : public AnimatorFunctionBase
619 AnimateByFloat(const float& relativeValue)
620 : mRelative(relativeValue)
624 float operator()(float alpha, const float& property)
626 return float(property + mRelative * alpha);
632 struct AnimateToFloat : public AnimatorFunctionBase
634 AnimateToFloat(const float& targetValue)
635 : mTarget(targetValue)
639 float operator()(float alpha, const float& property)
641 return float(property + ((mTarget - property) * alpha));
647 struct AnimateByVector2 : public AnimatorFunctionBase
649 AnimateByVector2(const Vector2& relativeValue)
650 : mRelative(relativeValue)
654 Vector2 operator()(float alpha, const Vector2& property)
656 return Vector2(property + mRelative * alpha);
662 struct AnimateToVector2 : public AnimatorFunctionBase
664 AnimateToVector2(const Vector2& targetValue)
665 : mTarget(targetValue)
669 Vector2 operator()(float alpha, const Vector2& property)
671 return Vector2(property + ((mTarget - property) * alpha));
677 struct AnimateByVector3 : public AnimatorFunctionBase
679 AnimateByVector3(const Vector3& relativeValue)
680 : mRelative(relativeValue)
684 Vector3 operator()(float alpha, const Vector3& property)
686 return Vector3(property + mRelative * alpha);
692 struct AnimateToVector3 : public AnimatorFunctionBase
694 AnimateToVector3(const Vector3& targetValue)
695 : mTarget(targetValue)
699 Vector3 operator()(float alpha, const Vector3& property)
701 return Vector3(property + ((mTarget - property) * alpha));
707 struct AnimateByVector4 : public AnimatorFunctionBase
709 AnimateByVector4(const Vector4& relativeValue)
710 : mRelative(relativeValue)
714 Vector4 operator()(float alpha, const Vector4& property)
716 return Vector4(property + mRelative * alpha);
722 struct AnimateToVector4 : public AnimatorFunctionBase
724 AnimateToVector4(const Vector4& targetValue)
725 : mTarget(targetValue)
729 Vector4 operator()(float alpha, const Vector4& property)
731 return Vector4(property + ((mTarget - property) * alpha));
737 struct AnimateByOpacity : public AnimatorFunctionBase
739 AnimateByOpacity(const float& relativeValue)
740 : mRelative(relativeValue)
744 Vector4 operator()(float alpha, const Vector4& property)
746 Vector4 result(property);
747 result.a += mRelative * alpha;
755 struct AnimateToOpacity : public AnimatorFunctionBase
757 AnimateToOpacity(const float& targetValue)
758 : mTarget(targetValue)
762 Vector4 operator()(float alpha, const Vector4& property)
764 Vector4 result(property);
765 result.a = property.a + ((mTarget - property.a) * alpha);
773 struct AnimateByBoolean : public AnimatorFunctionBase
775 AnimateByBoolean(bool relativeValue)
776 : mRelative(relativeValue)
780 bool operator()(float alpha, const bool& property)
782 // Alpha is not useful here, just keeping to the same template as other update functors
783 return bool(alpha >= 1.0f ? (property || mRelative) : property);
789 struct AnimateToBoolean : public AnimatorFunctionBase
791 AnimateToBoolean(bool targetValue)
792 : mTarget(targetValue)
796 bool operator()(float alpha, const bool& property)
798 // Alpha is not useful here, just keeping to the same template as other update functors
799 return bool(alpha >= 1.0f ? mTarget : property);
805 struct RotateByAngleAxis : public AnimatorFunctionBase
807 RotateByAngleAxis(const Radian& angleRadians, const Vector3& axis)
808 : mAngleRadians( angleRadians ),
809 mAxis(axis.x, axis.y, axis.z)
813 Quaternion operator()(float alpha, const Quaternion& rotation)
817 return rotation * Quaternion(mAngleRadians * alpha, mAxis);
823 Radian mAngleRadians;
827 struct RotateToQuaternion : public AnimatorFunctionBase
829 RotateToQuaternion(const Quaternion& targetValue)
830 : mTarget(targetValue)
834 Quaternion operator()(float alpha, const Quaternion& rotation)
836 return Quaternion::Slerp(rotation, mTarget, alpha);
843 struct KeyFrameBooleanFunctor : public AnimatorFunctionBase
845 KeyFrameBooleanFunctor(KeyFrameBooleanPtr keyFrames)
846 : mKeyFrames(keyFrames)
850 bool operator()(float progress, const bool& property)
852 if(mKeyFrames->IsActive(progress))
854 return mKeyFrames->GetValue(progress, Dali::Animation::Linear);
859 KeyFrameBooleanPtr mKeyFrames;
862 struct KeyFrameIntegerFunctor : public AnimatorFunctionBase
864 KeyFrameIntegerFunctor(KeyFrameIntegerPtr keyFrames, Interpolation interpolation)
865 : mKeyFrames(keyFrames),mInterpolation(interpolation)
869 float operator()(float progress, const int& property)
871 if(mKeyFrames->IsActive(progress))
873 return mKeyFrames->GetValue(progress, mInterpolation);
878 KeyFrameIntegerPtr mKeyFrames;
879 Interpolation mInterpolation;
882 struct KeyFrameNumberFunctor : public AnimatorFunctionBase
884 KeyFrameNumberFunctor(KeyFrameNumberPtr keyFrames, Interpolation interpolation)
885 : mKeyFrames(keyFrames),mInterpolation(interpolation)
889 float operator()(float progress, const float& property)
891 if(mKeyFrames->IsActive(progress))
893 return mKeyFrames->GetValue(progress, mInterpolation);
898 KeyFrameNumberPtr mKeyFrames;
899 Interpolation mInterpolation;
902 struct KeyFrameVector2Functor : public AnimatorFunctionBase
904 KeyFrameVector2Functor(KeyFrameVector2Ptr keyFrames, Interpolation interpolation)
905 : mKeyFrames(keyFrames),mInterpolation(interpolation)
909 Vector2 operator()(float progress, const Vector2& property)
911 if(mKeyFrames->IsActive(progress))
913 return mKeyFrames->GetValue(progress, mInterpolation);
918 KeyFrameVector2Ptr mKeyFrames;
919 Interpolation mInterpolation;
923 struct KeyFrameVector3Functor : public AnimatorFunctionBase
925 KeyFrameVector3Functor(KeyFrameVector3Ptr keyFrames, Interpolation interpolation)
926 : mKeyFrames(keyFrames),mInterpolation(interpolation)
930 Vector3 operator()(float progress, const Vector3& property)
932 if(mKeyFrames->IsActive(progress))
934 return mKeyFrames->GetValue(progress, mInterpolation);
939 KeyFrameVector3Ptr mKeyFrames;
940 Interpolation mInterpolation;
943 struct KeyFrameVector4Functor : public AnimatorFunctionBase
945 KeyFrameVector4Functor(KeyFrameVector4Ptr keyFrames, Interpolation interpolation)
946 : mKeyFrames(keyFrames),mInterpolation(interpolation)
950 Vector4 operator()(float progress, const Vector4& property)
952 if(mKeyFrames->IsActive(progress))
954 return mKeyFrames->GetValue(progress, mInterpolation);
959 KeyFrameVector4Ptr mKeyFrames;
960 Interpolation mInterpolation;
963 struct KeyFrameQuaternionFunctor : public AnimatorFunctionBase
965 KeyFrameQuaternionFunctor(KeyFrameQuaternionPtr keyFrames)
966 : mKeyFrames(keyFrames)
970 Quaternion operator()(float progress, const Quaternion& property)
972 if(mKeyFrames->IsActive(progress))
974 return mKeyFrames->GetValue(progress, Dali::Animation::Linear);
979 KeyFrameQuaternionPtr mKeyFrames;
982 struct PathPositionFunctor : public AnimatorFunctionBase
984 PathPositionFunctor( PathPtr path )
989 Vector3 operator()(float progress, const Vector3& property)
991 return mPath->SamplePosition(progress );
997 struct PathRotationFunctor : public AnimatorFunctionBase
999 PathRotationFunctor( PathPtr path, const Vector3& forward )
1003 mForward.Normalize();
1006 Quaternion operator()(float progress, const Quaternion& property)
1008 Vector3 tangent( mPath->SampleTangent(progress) );
1009 return Quaternion( mForward, tangent );
1017 } // namespace Internal
1021 #endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__