dali/internal/update/animation/scene-graph-animator.h

   1 #ifndef __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__
   2 #define __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__
   3
   4 /*
   5  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   6  *
   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
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  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-functions.h>
  28 #include <dali/public-api/animation/animation.h>
  29 #include <dali/public-api/animation/time-period.h>
  30 #include <dali/public-api/common/dali-common.h>
  31 #include <dali/public-api/math/quaternion.h>
  32 #include <dali/public-api/math/radian.h>
  33
  34 namespace Dali
  35 {
  36
  37 namespace Internal
  38 {
  39
  40 typedef Dali::Animation::Interpolation Interpolation;
  41
  42 struct AnimatorFunctionBase;
  43
  44 namespace SceneGraph
  45 {
  46
  47 class AnimatorBase;
  48
  49 typedef OwnerContainer< AnimatorBase* > AnimatorContainer;
  50
  51 typedef AnimatorContainer::Iterator AnimatorIter;
  52 typedef AnimatorContainer::ConstIterator AnimatorConstIter;
  53
  54 /**
  55  * An abstract base class for Animators, which can be added to scene graph animations.
  56  * Each animator changes a single property of an object in the scene graph.
  57  */
  58 class AnimatorBase
  59 {
  60 public:
  61
  62   typedef float (*AlphaFunc)(float progress); ///< Definition of an alpha function
  63
  64   /**
  65    * Constructor.
  66    */
  67   AnimatorBase()
  68   : mDurationSeconds(1.0f),
  69     mInitialDelaySeconds(0.0f),
  70     mAlphaFunc(AlphaFunctions::Linear),
  71     mDisconnectAction(Dali::Animation::BakeFinal),
  72     mActive(false),
  73     mEnabled(true)
  74   {
  75   }
  76
  77   /**
  78    * Virtual destructor.
  79    */
  80   virtual ~AnimatorBase()
  81   {
  82   }
  83
  84   /**
  85    * Set the duration of the animator.
  86    * @pre durationSeconds must be zero or greater; zero is useful when animating boolean values.
  87    * @param [in] seconds Duration in seconds.
  88    */
  89   void SetDuration(float seconds)
  90   {
  91     DALI_ASSERT_DEBUG(seconds >= 0.0f);
  92
  93     mDurationSeconds = seconds;
  94   }
  95
  96   /**
  97    * Retrieve the duration of the animator.
  98    * @return The duration in seconds.
  99    */
 100   float GetDuration()
 101   {
 102     return mDurationSeconds;
 103   }
 104
 105   /**
 106    * Set the delay before the animator should take effect.
 107    * The default is zero i.e. no delay.
 108    * @param [in] seconds The delay in seconds.
 109    */
 110   void SetInitialDelay(float seconds)
 111   {
 112     mInitialDelaySeconds = seconds;
 113   }
 114
 115   /**
 116    * Retrieve the initial delay of the animator.
 117    * @return The delay in seconds.
 118    */
 119   float GetInitialDelay()
 120   {
 121     return mInitialDelaySeconds;
 122   }
 123
 124   /**
 125    * Set the alpha function for an animator.
 126    * @param [in] alphaFunc The alpha function to apply to the animation progress.
 127    */
 128   void SetAlphaFunc(AlphaFunc alphaFunc)
 129   {
 130     mAlphaFunc = alphaFunc;
 131   }
 132
 133   /**
 134    * Retrieve the alpha function of an animator.
 135    * @return The function.
 136    */
 137   AlphaFunc GetAlphaFunc() const
 138   {
 139     return mAlphaFunc;
 140   }
 141
 142   /**
 143    * Whether to bake the animation if attached property owner is disconnected.
 144    * Property is only baked if the animator is active.
 145    * @param [in] action The disconnect action.
 146    */
 147   void SetDisconnectAction( Dali::Animation::EndAction action )
 148   {
 149     mDisconnectAction = action;
 150   }
 151
 152   /**
 153    * Retrieve the disconnect action of an animator.
 154    * @return The disconnect action.
 155    */
 156   Dali::Animation::EndAction GetDisconnectAction() const
 157   {
 158     return mDisconnectAction;
 159   }
 160
 161   /**
 162    * Whether the animator is active or not.
 163    * @param [in] active The new active state.
 164    * @post When the animator becomes active, it applies the disconnect-action if the property owner is then disconnected.
 165    * @note When the property owner is disconnected, the active state is set to false.
 166    */
 167   void SetActive( bool active )
 168   {
 169     mActive = active;
 170   }
 171
 172   /**
 173    * Retrieve whether the animator has been set to active or not.
 174    * @return The active state.
 175    */
 176   bool GetActive() const
 177   {
 178     return mActive;
 179   }
 180
 181   /*
 182    * Retrive wheter the animator's target object is valid and on the stage.
 183    * @return The enabled state.
 184    */
 185   bool IsEnabled() const
 186   {
 187     return mEnabled;
 188   }
 189   /**
 190    * Returns wheter the target object of the animator is still valid
 191    * or has been destroyed.
 192    * @return True if animator is orphan, false otherwise   *
 193    * @note The SceneGraph::Animation will delete any orphan animator in its Update method.
 194    */
 195   virtual bool Orphan() = 0;
 196
 197   /**
 198    * Update the scene object attached to the animator.
 199    * @param[in] bufferIndex The buffer to animate.
 200    * @param[in] progress A value from 0 to 1, where 0 is the start of the animation, and 1 is the end point.
 201    * @param[in] bake Bake.
 202    */
 203   virtual void Update(BufferIndex bufferIndex, float progress, bool bake) = 0;
 204
 205 protected:
 206
 207   float mDurationSeconds;
 208   float mInitialDelaySeconds;
 209
 210   AlphaFunc mAlphaFunc;
 211
 212   Dali::Animation::EndAction mDisconnectAction;     ///< EndAction to apply when target object gets disconnected from the stage.
 213   bool mActive:1;                                   ///< Animator is "active" while it's running.
 214   bool mEnabled:1;                                  ///< Animator is "enabled" while its target object is valid and on the stage.
 215 };
 216
 217 /**
 218  * An animator for a specific property type PropertyType.
 219  */
 220 template < typename PropertyType, typename PropertyAccessorType >
 221 class Animator : public AnimatorBase, public PropertyOwner::Observer
 222 {
 223 public:
 224
 225   /**
 226    * Construct a new property animator.
 227    * @param[in] property The animatable property; only valid while the Animator is attached.
 228    * @param[in] animatorFunction The function used to animate the property.
 229    * @param[in] alphaFunction The alpha function to apply.
 230    * @param[in] timePeriod The time period of this animation.
 231    * @return A newly allocated animator.
 232    */
 233   static AnimatorBase* New( const PropertyOwner& propertyOwner,
 234                             const PropertyBase& property,
 235                             AnimatorFunctionBase* animatorFunction,
 236                             AlphaFunction alphaFunction,
 237                             const TimePeriod& timePeriod )
 238   {
 239     typedef Animator< PropertyType, PropertyAccessorType > AnimatorType;
 240
 241     // The property was const in the actor-thread, but animators are used in the scene-graph thread.
 242     AnimatorType* animator = new AnimatorType( const_cast<PropertyOwner*>( &propertyOwner ),
 243                                                const_cast<PropertyBase*>( &property ),
 244                                                animatorFunction );
 245
 246     animator->SetAlphaFunc( alphaFunction );
 247     animator->SetInitialDelay( timePeriod.delaySeconds );
 248     animator->SetDuration( timePeriod.durationSeconds );
 249
 250     return animator;
 251   }
 252
 253   /**
 254    * Virtual destructor.
 255    */
 256   virtual ~Animator()
 257   {
 258     if (mPropertyOwner)
 259     {
 260       mPropertyOwner->RemoveObserver(*this);
 261     }
 262
 263     if( mAnimatorFunction )
 264     {
 265       delete mAnimatorFunction;
 266     }
 267   }
 268
 269   /**
 270    * Called when mPropertyOwner is connected to the scene graph.
 271    */
 272   virtual void PropertyOwnerConnected( PropertyOwner& owner )
 273   {
 274     mEnabled = true;
 275   }
 276
 277   /**
 278    * Called when mPropertyOwner is disconnected from the scene graph.
 279    */
 280   virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
 281   {
 282     // If we are active, then bake the value if required
 283     if ( mActive && mDisconnectAction != Dali::Animation::Discard )
 284     {
 285       // Bake to target-value if BakeFinal, otherwise bake current value
 286       Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true );
 287     }
 288
 289     mActive = false;
 290     mEnabled = false;
 291   }
 292
 293   /**
 294    * Called shortly before mPropertyOwner is destroyed
 295    */
 296   virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
 297   {
 298     mPropertyOwner = NULL;
 299     mPropertyAccessor.Reset();
 300     mEnabled = false;
 301   }
 302
 303   /**
 304    * From AnimatorBase.
 305    */
 306   virtual void Update( BufferIndex bufferIndex, float progress, bool bake )
 307   {
 308     float alpha = mAlphaFunc( progress );
 309     const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
 310
 311     const PropertyType result = (*mAnimatorFunction)( alpha, current );
 312     if ( bake )
 313     {
 314       mPropertyAccessor.Bake( bufferIndex, result );
 315     }
 316     else
 317     {
 318       mPropertyAccessor.Set( bufferIndex, result );
 319     }
 320
 321     mCurrentProgress = progress;
 322   }
 323
 324   /**
 325    * From AnimatorBase.
 326    */
 327   virtual bool Orphan()
 328   {
 329     return (mPropertyOwner == NULL);
 330   }
 331
 332 private:
 333
 334   /**
 335    * Private constructor; see also Animator::New().
 336    */
 337   Animator( PropertyOwner* propertyOwner,
 338             PropertyBase* property,
 339             AnimatorFunctionBase* animatorFunction )
 340   : mPropertyOwner( propertyOwner ),
 341     mPropertyAccessor( property ),
 342     mAnimatorFunction( animatorFunction ),
 343     mCurrentProgress( 0.0f )
 344   {
 345     mPropertyOwner->AddObserver(*this);
 346   }
 347
 348   // Undefined
 349   Animator( const Animator& );
 350
 351   // Undefined
 352   Animator& operator=( const Animator& );
 353
 354 protected:
 355
 356   PropertyOwner* mPropertyOwner;
 357   PropertyAccessorType mPropertyAccessor;
 358
 359   AnimatorFunctionBase* mAnimatorFunction;
 360   float mCurrentProgress;
 361 };
 362
 363 } // namespace SceneGraph
 364
 365 /*
 366  * AnimatorFunction base class.
 367  * All update functions must inherit from AnimatorFunctionBase and overload the appropiate "()" operator
 368  */
 369 struct AnimatorFunctionBase
 370 {
 371   /**
 372    * Constructor
 373    */
 374   AnimatorFunctionBase(){}
 375
 376   /*
 377    * Virtual destructor (Intended as base class)
 378    */
 379   virtual ~AnimatorFunctionBase(){}
 380
 381   ///Stub "()" operators.
 382   virtual float operator()(float progress, const int& property)
 383   {
 384     return property;
 385   }
 386
 387   virtual float operator()(float progress, const float& property)
 388   {
 389     return property;
 390   }
 391
 392   virtual bool operator()(float progress, const bool& property)
 393   {
 394     return property;
 395   }
 396
 397   virtual Vector2 operator()(float progress, const Vector2& property)
 398   {
 399     return property;
 400   }
 401
 402   virtual Vector3 operator()(float progress, const Vector3& property)
 403   {
 404     return property;
 405   }
 406
 407   virtual Vector4 operator()(float progress, const Vector4& property)
 408   {
 409     return property;
 410   }
 411
 412   virtual Quaternion operator()(float progress, const Quaternion& property)
 413   {
 414     return property;
 415   }
 416 };
 417
 418 // Update functions
 419
 420 struct AnimateByFloat : public AnimatorFunctionBase
 421 {
 422   AnimateByFloat(const float& relativeValue)
 423   : mRelative(relativeValue)
 424   {
 425   }
 426
 427   float operator()(float alpha, const float& property)
 428   {
 429     return float(property + mRelative * alpha);
 430   }
 431
 432   float mRelative;
 433 };
 434
 435 struct AnimateToFloat : public AnimatorFunctionBase
 436 {
 437   AnimateToFloat(const float& targetValue)
 438   : mTarget(targetValue)
 439   {
 440   }
 441
 442   float operator()(float alpha, const float& property)
 443   {
 444     return float(property + ((mTarget - property) * alpha));
 445   }
 446
 447   float mTarget;
 448 };
 449
 450 struct AnimateByInteger : public AnimatorFunctionBase
 451 {
 452   AnimateByInteger(const int& relativeValue)
 453   : mRelative(relativeValue)
 454   {
 455   }
 456
 457   float operator()(float alpha, const int& property)
 458   {
 459     return int(property + mRelative * alpha + 0.5f );
 460   }
 461
 462   int mRelative;
 463 };
 464
 465 struct AnimateToInteger : public AnimatorFunctionBase
 466 {
 467   AnimateToInteger(const int& targetValue)
 468   : mTarget(targetValue)
 469   {
 470   }
 471
 472   float operator()(float alpha, const int& property)
 473   {
 474     return int(property + ((mTarget - property) * alpha) + 0.5f);
 475   }
 476
 477   int mTarget;
 478 };
 479
 480 struct AnimateByVector2 : public AnimatorFunctionBase
 481 {
 482   AnimateByVector2(const Vector2& relativeValue)
 483   : mRelative(relativeValue)
 484   {
 485   }
 486
 487   Vector2 operator()(float alpha, const Vector2& property)
 488   {
 489     return Vector2(property + mRelative * alpha);
 490   }
 491
 492   Vector2 mRelative;
 493 };
 494
 495 struct AnimateToVector2 : public AnimatorFunctionBase
 496 {
 497   AnimateToVector2(const Vector2& targetValue)
 498   : mTarget(targetValue)
 499   {
 500   }
 501
 502   Vector2 operator()(float alpha, const Vector2& property)
 503   {
 504     return Vector2(property + ((mTarget - property) * alpha));
 505   }
 506
 507   Vector2 mTarget;
 508 };
 509
 510 struct AnimateByVector3 : public AnimatorFunctionBase
 511 {
 512   AnimateByVector3(const Vector3& relativeValue)
 513   : mRelative(relativeValue)
 514   {
 515   }
 516
 517   Vector3 operator()(float alpha, const Vector3& property)
 518   {
 519     return Vector3(property + mRelative * alpha);
 520   }
 521
 522   Vector3 mRelative;
 523 };
 524
 525 struct AnimateToVector3 : public AnimatorFunctionBase
 526 {
 527   AnimateToVector3(const Vector3& targetValue)
 528   : mTarget(targetValue)
 529   {
 530   }
 531
 532   Vector3 operator()(float alpha, const Vector3& property)
 533   {
 534     return Vector3(property + ((mTarget - property) * alpha));
 535   }
 536
 537   Vector3 mTarget;
 538 };
 539
 540 struct AnimateByVector4 : public AnimatorFunctionBase
 541 {
 542   AnimateByVector4(const Vector4& relativeValue)
 543   : mRelative(relativeValue)
 544   {
 545   }
 546
 547   Vector4 operator()(float alpha, const Vector4& property)
 548   {
 549     return Vector4(property + mRelative * alpha);
 550   }
 551
 552   Vector4 mRelative;
 553 };
 554
 555 struct AnimateToVector4 : public AnimatorFunctionBase
 556 {
 557   AnimateToVector4(const Vector4& targetValue)
 558   : mTarget(targetValue)
 559   {
 560   }
 561
 562   Vector4 operator()(float alpha, const Vector4& property)
 563   {
 564     return Vector4(property + ((mTarget - property) * alpha));
 565   }
 566
 567   Vector4 mTarget;
 568 };
 569
 570 struct AnimateByOpacity : public AnimatorFunctionBase
 571 {
 572   AnimateByOpacity(const float& relativeValue)
 573   : mRelative(relativeValue)
 574   {
 575   }
 576
 577   Vector4 operator()(float alpha, const Vector4& property)
 578   {
 579     Vector4 result(property);
 580     result.a += mRelative * alpha;
 581
 582     return result;
 583   }
 584
 585   float mRelative;
 586 };
 587
 588 struct AnimateToOpacity : public AnimatorFunctionBase
 589 {
 590   AnimateToOpacity(const float& targetValue)
 591   : mTarget(targetValue)
 592   {
 593   }
 594
 595   Vector4 operator()(float alpha, const Vector4& property)
 596   {
 597     Vector4 result(property);
 598     result.a = property.a + ((mTarget - property.a) * alpha);
 599
 600     return result;
 601   }
 602
 603   float mTarget;
 604 };
 605
 606 struct AnimateByBoolean : public AnimatorFunctionBase
 607 {
 608   AnimateByBoolean(bool relativeValue)
 609   : mRelative(relativeValue)
 610   {
 611   }
 612
 613   bool operator()(float alpha, const bool& property)
 614   {
 615     // Alpha is not useful here, just keeping to the same template as other update functors
 616     return bool(alpha >= 1.0f ? (property || mRelative) : property);
 617   }
 618
 619   bool mRelative;
 620 };
 621
 622 struct AnimateToBoolean : public AnimatorFunctionBase
 623 {
 624   AnimateToBoolean(bool targetValue)
 625   : mTarget(targetValue)
 626   {
 627   }
 628
 629   bool operator()(float alpha, const bool& property)
 630   {
 631     // Alpha is not useful here, just keeping to the same template as other update functors
 632     return bool(alpha >= 1.0f ? mTarget : property);
 633   }
 634
 635   bool mTarget;
 636 };
 637
 638 struct RotateByAngleAxis : public AnimatorFunctionBase
 639 {
 640   RotateByAngleAxis(const Radian& angleRadians, const Vector3& axis)
 641   : mAngleRadians( angleRadians ),
 642     mAxis(axis.x, axis.y, axis.z)
 643   {
 644   }
 645
 646   Quaternion operator()(float alpha, const Quaternion& rotation)
 647   {
 648     if (alpha > 0.0f)
 649     {
 650       return rotation * Quaternion(mAngleRadians * alpha, mAxis);
 651     }
 652
 653     return rotation;
 654   }
 655
 656   Radian mAngleRadians;
 657   Vector3 mAxis;
 658 };
 659
 660 struct RotateToQuaternion : public AnimatorFunctionBase
 661 {
 662   RotateToQuaternion(const Quaternion& targetValue)
 663   : mTarget(targetValue)
 664   {
 665   }
 666
 667   Quaternion operator()(float alpha, const Quaternion& rotation)
 668   {
 669     return Quaternion::Slerp(rotation, mTarget, alpha);
 670   }
 671
 672   Quaternion mTarget;
 673 };
 674
 675
 676 struct KeyFrameBooleanFunctor : public AnimatorFunctionBase
 677 {
 678   KeyFrameBooleanFunctor(KeyFrameBooleanPtr keyFrames)
 679   : mKeyFrames(keyFrames)
 680   {
 681   }
 682
 683   bool operator()(float progress, const bool& property)
 684   {
 685     if(mKeyFrames->IsActive(progress))
 686     {
 687       return mKeyFrames->GetValue(progress, Dali::Animation::Linear);
 688     }
 689     return property;
 690   }
 691
 692   KeyFrameBooleanPtr mKeyFrames;
 693 };
 694
 695 struct KeyFrameNumberFunctor : public AnimatorFunctionBase
 696 {
 697   KeyFrameNumberFunctor(KeyFrameNumberPtr keyFrames, Interpolation interpolation)
 698   : mKeyFrames(keyFrames),mInterpolation(interpolation)
 699   {
 700   }
 701
 702   float operator()(float progress, const float& property)
 703   {
 704     if(mKeyFrames->IsActive(progress))
 705     {
 706       return mKeyFrames->GetValue(progress, mInterpolation);
 707     }
 708     return property;
 709   }
 710
 711   KeyFrameNumberPtr mKeyFrames;
 712   Interpolation mInterpolation;
 713 };
 714
 715 struct KeyFrameIntegerFunctor : public AnimatorFunctionBase
 716 {
 717   KeyFrameIntegerFunctor(KeyFrameIntegerPtr keyFrames, Interpolation interpolation)
 718   : mKeyFrames(keyFrames),mInterpolation(interpolation)
 719   {
 720   }
 721
 722   float operator()(float progress, const int& property)
 723   {
 724     if(mKeyFrames->IsActive(progress))
 725     {
 726       return mKeyFrames->GetValue(progress, mInterpolation);
 727     }
 728     return property;
 729   }
 730
 731   KeyFrameIntegerPtr mKeyFrames;
 732   Interpolation mInterpolation;
 733 };
 734
 735 struct KeyFrameVector2Functor : public AnimatorFunctionBase
 736 {
 737   KeyFrameVector2Functor(KeyFrameVector2Ptr keyFrames, Interpolation interpolation)
 738   : mKeyFrames(keyFrames),mInterpolation(interpolation)
 739   {
 740   }
 741
 742   Vector2 operator()(float progress, const Vector2& property)
 743   {
 744     if(mKeyFrames->IsActive(progress))
 745     {
 746       return mKeyFrames->GetValue(progress, mInterpolation);
 747     }
 748     return property;
 749   }
 750
 751   KeyFrameVector2Ptr mKeyFrames;
 752   Interpolation mInterpolation;
 753 };
 754
 755
 756 struct KeyFrameVector3Functor : public AnimatorFunctionBase
 757 {
 758   KeyFrameVector3Functor(KeyFrameVector3Ptr keyFrames, Interpolation interpolation)
 759   : mKeyFrames(keyFrames),mInterpolation(interpolation)
 760   {
 761   }
 762
 763   Vector3 operator()(float progress, const Vector3& property)
 764   {
 765     if(mKeyFrames->IsActive(progress))
 766     {
 767       return mKeyFrames->GetValue(progress, mInterpolation);
 768     }
 769     return property;
 770   }
 771
 772   KeyFrameVector3Ptr mKeyFrames;
 773   Interpolation mInterpolation;
 774 };
 775
 776 struct KeyFrameVector4Functor : public AnimatorFunctionBase
 777 {
 778   KeyFrameVector4Functor(KeyFrameVector4Ptr keyFrames, Interpolation interpolation)
 779   : mKeyFrames(keyFrames),mInterpolation(interpolation)
 780   {
 781   }
 782
 783   Vector4 operator()(float progress, const Vector4& property)
 784   {
 785     if(mKeyFrames->IsActive(progress))
 786     {
 787       return mKeyFrames->GetValue(progress, mInterpolation);
 788     }
 789     return property;
 790   }
 791
 792   KeyFrameVector4Ptr mKeyFrames;
 793   Interpolation mInterpolation;
 794 };
 795
 796 struct KeyFrameQuaternionFunctor : public AnimatorFunctionBase
 797 {
 798   KeyFrameQuaternionFunctor(KeyFrameQuaternionPtr keyFrames)
 799   : mKeyFrames(keyFrames)
 800   {
 801   }
 802
 803   Quaternion operator()(float progress, const Quaternion& property)
 804   {
 805     if(mKeyFrames->IsActive(progress))
 806     {
 807       return mKeyFrames->GetValue(progress, Dali::Animation::Linear);
 808     }
 809     return property;
 810   }
 811
 812   KeyFrameQuaternionPtr mKeyFrames;
 813 };
 814
 815 struct PathPositionFunctor : public AnimatorFunctionBase
 816 {
 817   PathPositionFunctor( PathPtr path )
 818   : mPath(path)
 819   {
 820   }
 821
 822   Vector3 operator()(float progress, const Vector3& property)
 823   {
 824     return mPath->SamplePosition(progress );
 825   }
 826
 827   PathPtr mPath;
 828 };
 829
 830 struct PathRotationFunctor : public AnimatorFunctionBase
 831 {
 832   PathRotationFunctor( PathPtr path, const Vector3& forward )
 833   : mPath(path),
 834     mForward( forward )
 835   {
 836     mForward.Normalize();
 837   }
 838
 839   Quaternion operator()(float progress, const Quaternion& property)
 840   {
 841     Vector3 tangent( mPath->SampleTangent(progress) );
 842     return Quaternion( mForward, tangent );
 843   }
 844
 845   PathPtr mPath;
 846   Vector3 mForward;
 847 };
 848
 849
 850 } // namespace Internal
 851
 852 } // namespace Dali
 853
 854 #endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__