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 <boost/function.hpp>
25 #include <dali/internal/common/owner-container.h>
26 #include <dali/internal/event/animation/key-frames-impl.h>
27 #include <dali/internal/update/nodes/node.h>
28 #include <dali/internal/update/common/property-base.h>
29 #include <dali/internal/common/observer-pointer.h>
30 #include <dali/public-api/animation/alpha-functions.h>
31 #include <dali/public-api/animation/time-period.h>
32 #include <dali/public-api/common/dali-common.h>
33 #include <dali/public-api/math/quaternion.h>
34 #include <dali/public-api/math/radian.h>
47 typedef OwnerContainer< AnimatorBase* > AnimatorContainer;
49 typedef AnimatorContainer::Iterator AnimatorIter;
50 typedef AnimatorContainer::ConstIterator AnimatorConstIter;
53 * An abstract base class for Animators, which can be added to scene graph animations.
54 * Each animator changes a single property of an object in the scene graph.
60 typedef float (*AlphaFunc)(float progress); ///< Definition of an alpha function
66 : mDurationSeconds(1.0f),
67 mInitialDelaySeconds(0.0f),
68 mAlphaFunc(AlphaFunctions::Linear),
76 virtual ~AnimatorBase()
81 * Set the duration of the animator.
82 * @pre durationSeconds must be zero or greater; zero is useful when animating boolean values.
83 * @param [in] seconds Duration in seconds.
85 void SetDuration(float seconds)
87 DALI_ASSERT_DEBUG(seconds >= 0.0f);
89 mDurationSeconds = seconds;
93 * Retrieve the duration of the animator.
94 * @return The duration in seconds.
98 return mDurationSeconds;
102 * Set the delay before the animator should take effect.
103 * The default is zero i.e. no delay.
104 * @param [in] seconds The delay in seconds.
106 void SetInitialDelay(float seconds)
108 mInitialDelaySeconds = seconds;
112 * Retrieve the initial delay of the animator.
113 * @return The delay in seconds.
115 float GetInitialDelay()
117 return mInitialDelaySeconds;
121 * Set the alpha function for an animator.
122 * @param [in] alphaFunc The alpha function to apply to the animation progress.
124 void SetAlphaFunc(AlphaFunc alphaFunc)
126 mAlphaFunc = alphaFunc;
130 * Retrieve the alpha function of an animator.
131 * @return The function.
133 AlphaFunc GetAlphaFunc() const
139 * This must be called when the animator is attached to the scene-graph.
140 * @pre The animatable scene object must also be attached to the scene-graph.
141 * @param[in] propertyOwner The scene-object that owns the animatable property.
143 virtual void Attach( PropertyOwner* propertyOwner ) = 0;
146 * Update the scene object attached to the animator.
147 * @param[in] bufferIndex The buffer to animate.
148 * @param[in] progress A value from 0 to 1, where 0 is the start of the animation, and 1 is the end point.
149 * @param[in] bake Bake.
150 * @return True if the update was applied, false if the animator has been orphaned.
152 virtual bool Update(BufferIndex bufferIndex, float progress, bool bake) = 0;
155 * Query whether the animator is still attached to a scene object.
156 * The attachment will be automatically severed, when the object is destroyed.
157 * @return True if the animator is attached.
159 virtual bool IsAttached() const = 0;
163 float mDurationSeconds;
164 float mInitialDelaySeconds;
166 AlphaFunc mAlphaFunc;
172 * An animator for a specific property type PropertyType.
174 template < typename PropertyType, typename PropertyAccessorType >
175 class Animator : public AnimatorBase, public PropertyOwner::Observer
179 typedef boost::function< PropertyType (float, const PropertyType&) > AnimatorFunction;
182 * Construct a new property animator.
183 * @param[in] property The animatable property; only valid while the Animator is attached.
184 * @param[in] animatorFunction The function used to animate the property.
185 * @param[in] alphaFunction The alpha function to apply.
186 * @param[in] timePeriod The time period of this animation.
187 * @return A newly allocated animator.
189 static AnimatorBase* New( const PropertyBase& property,
190 AnimatorFunction animatorFunction,
191 AlphaFunction alphaFunction,
192 const TimePeriod& timePeriod )
194 typedef Animator< PropertyType, PropertyAccessorType > AnimatorType;
196 // The property was const in the actor-thread, but animators are used in the scene-graph thread.
197 AnimatorType* animator = new AnimatorType( const_cast<PropertyBase*>( &property ),
200 animator->SetAlphaFunc( alphaFunction );
201 animator->SetInitialDelay( timePeriod.delaySeconds );
202 animator->SetDuration( timePeriod.durationSeconds );
208 * Virtual destructor.
214 mPropertyOwner->RemoveObserver(*this);
220 * @param[in] propertyOwner The scene-object that owns the animatable property.
222 virtual void Attach( PropertyOwner* propertyOwner )
224 mPropertyOwner = propertyOwner;
228 mPropertyOwner->AddObserver(*this);
235 virtual bool Update( BufferIndex bufferIndex, float progress, bool bake )
237 // If the object dies, the animator has no effect
238 if ( mPropertyOwner )
240 float alpha = mAlphaFunc( progress );
242 const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
244 const PropertyType result = mAnimatorFunction( alpha, current );
248 mPropertyAccessor.Bake( bufferIndex, result );
252 mPropertyAccessor.Set( bufferIndex, result );
256 return IsAttached(); // return false if orphaned
262 virtual bool IsAttached() const
264 return NULL != mPropertyOwner;
268 * Called shortly before mPropertyOwner is destroyed, along with its property.
270 virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
272 mPropertyOwner = NULL;
273 mPropertyAccessor.Reset();
279 * Private constructor; see also Animator::New().
281 Animator( PropertyBase* property,
282 AnimatorFunction animatorFunction )
283 : mPropertyOwner( NULL ),
284 mPropertyAccessor( property ),
285 mAnimatorFunction( animatorFunction )
290 Animator( const Animator& );
293 Animator& operator=( const Animator& );
297 PropertyOwner* mPropertyOwner;
298 PropertyAccessorType mPropertyAccessor;
300 AnimatorFunction mAnimatorFunction;
303 } // namespace SceneGraph
306 // Common Update functions
308 struct AnimateByFloat
310 AnimateByFloat(const float& relativeValue)
311 : mRelative(relativeValue)
315 float operator()(float alpha, const float& property)
317 return float(property + mRelative * alpha);
323 struct AnimateToFloat
325 AnimateToFloat(const float& targetValue)
326 : mTarget(targetValue)
330 float operator()(float alpha, const float& property)
332 return float(property + ((mTarget - property) * alpha));
338 struct AnimateByInteger
340 AnimateByInteger(const int& relativeValue)
341 : mRelative(relativeValue)
345 float operator()(float alpha, const int& property)
347 return int(property + mRelative * alpha + 0.5f );
353 struct AnimateToInteger
355 AnimateToInteger(const int& targetValue)
356 : mTarget(targetValue)
360 float operator()(float alpha, const int& property)
362 return int(property + ((mTarget - property) * alpha) + 0.5f);
368 struct AnimateByVector2
370 AnimateByVector2(const Vector2& relativeValue)
371 : mRelative(relativeValue)
375 Vector2 operator()(float alpha, const Vector2& property)
377 return Vector2(property + mRelative * alpha);
383 struct AnimateToVector2
385 AnimateToVector2(const Vector2& targetValue)
386 : mTarget(targetValue)
390 Vector2 operator()(float alpha, const Vector2& property)
392 return Vector2(property + ((mTarget - property) * alpha));
398 struct AnimateByVector3
400 AnimateByVector3(const Vector3& relativeValue)
401 : mRelative(relativeValue)
405 Vector3 operator()(float alpha, const Vector3& property)
407 return Vector3(property + mRelative * alpha);
413 struct AnimateToVector3
415 AnimateToVector3(const Vector3& targetValue)
416 : mTarget(targetValue)
420 Vector3 operator()(float alpha, const Vector3& property)
422 return Vector3(property + ((mTarget - property) * alpha));
428 struct AnimateByVector4
430 AnimateByVector4(const Vector4& relativeValue)
431 : mRelative(relativeValue)
435 Vector4 operator()(float alpha, const Vector4& property)
437 return Vector4(property + mRelative * alpha);
443 struct AnimateToVector4
445 AnimateToVector4(const Vector4& targetValue)
446 : mTarget(targetValue)
450 Vector4 operator()(float alpha, const Vector4& property)
452 return Vector4(property + ((mTarget - property) * alpha));
458 struct AnimateByOpacity
460 AnimateByOpacity(const float& relativeValue)
461 : mRelative(relativeValue)
465 Vector4 operator()(float alpha, const Vector4& property)
467 Vector4 result(property);
468 result.a += mRelative * alpha;
476 struct AnimateToOpacity
478 AnimateToOpacity(const float& targetValue)
479 : mTarget(targetValue)
483 Vector4 operator()(float alpha, const Vector4& property)
485 Vector4 result(property);
486 result.a = property.a + ((mTarget - property.a) * alpha);
494 struct AnimateByBoolean
496 AnimateByBoolean(bool relativeValue)
497 : mRelative(relativeValue)
501 bool operator()(float alpha, const bool& property)
503 // Alpha is not useful here, just keeping to the same template as other update functors
504 return bool(alpha >= 1.0f ? (property || mRelative) : property);
510 struct AnimateToBoolean
512 AnimateToBoolean(bool targetValue)
513 : mTarget(targetValue)
517 bool operator()(float alpha, const bool& property)
519 // Alpha is not useful here, just keeping to the same template as other update functors
520 return bool(alpha >= 1.0f ? mTarget : property);
526 struct RotateByAngleAxis
528 RotateByAngleAxis(const Radian& angleRadians, const Vector3& axis)
529 : mAngleRadians(angleRadians),
530 mAxis(axis.x, axis.y, axis.z, 0.0f)
534 Quaternion operator()(float alpha, const Quaternion& rotation)
538 return rotation * Quaternion(mAngleRadians * alpha, mAxis);
548 struct RotateToQuaternion
550 RotateToQuaternion(const Quaternion& targetValue)
551 : mTarget(targetValue)
555 Quaternion operator()(float alpha, const Quaternion& rotation)
557 return Quaternion::Slerp(rotation, mTarget, alpha);
564 struct KeyFrameBooleanFunctor
566 KeyFrameBooleanFunctor(KeyFrameBooleanPtr keyFrames)
567 : mKeyFrames(keyFrames)
571 bool operator()(float progress, const bool& property)
573 if(mKeyFrames->IsActive(progress))
575 return mKeyFrames->GetValue(progress);
580 KeyFrameBooleanPtr mKeyFrames;
583 struct KeyFrameNumberFunctor
585 KeyFrameNumberFunctor(KeyFrameNumberPtr keyFrames)
586 : mKeyFrames(keyFrames)
590 float operator()(float progress, const float& property)
592 if(mKeyFrames->IsActive(progress))
594 return mKeyFrames->GetValue(progress);
599 KeyFrameNumberPtr mKeyFrames;
602 struct KeyFrameIntegerFunctor
604 KeyFrameIntegerFunctor(KeyFrameIntegerPtr keyFrames)
605 : mKeyFrames(keyFrames)
609 float operator()(float progress, const int& property)
611 if(mKeyFrames->IsActive(progress))
613 return mKeyFrames->GetValue(progress);
618 KeyFrameIntegerPtr mKeyFrames;
621 struct KeyFrameVector2Functor
623 KeyFrameVector2Functor(KeyFrameVector2Ptr keyFrames)
624 : mKeyFrames(keyFrames)
628 Vector2 operator()(float progress, const Vector2& property)
630 if(mKeyFrames->IsActive(progress))
632 return mKeyFrames->GetValue(progress);
637 KeyFrameVector2Ptr mKeyFrames;
641 struct KeyFrameVector3Functor
643 KeyFrameVector3Functor(KeyFrameVector3Ptr keyFrames)
644 : mKeyFrames(keyFrames)
648 Vector3 operator()(float progress, const Vector3& property)
650 if(mKeyFrames->IsActive(progress))
652 return mKeyFrames->GetValue(progress);
657 KeyFrameVector3Ptr mKeyFrames;
660 struct KeyFrameVector4Functor
662 KeyFrameVector4Functor(KeyFrameVector4Ptr keyFrames)
663 : mKeyFrames(keyFrames)
667 Vector4 operator()(float progress, const Vector4& property)
669 if(mKeyFrames->IsActive(progress))
671 return mKeyFrames->GetValue(progress);
676 KeyFrameVector4Ptr mKeyFrames;
679 struct KeyFrameQuaternionFunctor
681 KeyFrameQuaternionFunctor(KeyFrameQuaternionPtr keyFrames)
682 : mKeyFrames(keyFrames)
686 Quaternion operator()(float progress, const Quaternion& property)
688 if(mKeyFrames->IsActive(progress))
690 return mKeyFrames->GetValue(progress);
695 KeyFrameQuaternionPtr mKeyFrames;
701 } // namespace Internal
705 #endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__