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/devel-api/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>
  34 #include <dali/internal/update/animation/property-accessor.h>
  35
  36
  37 namespace Dali
  38 {
  39
  40 namespace Internal
  41 {
  42
  43 typedef Dali::Animation::Interpolation Interpolation;
  44
  45 struct AnimatorFunctionBase;
  46
  47 namespace SceneGraph
  48 {
  49
  50 class AnimatorBase;
  51
  52 typedef OwnerContainer< AnimatorBase* > AnimatorContainer;
  53
  54 typedef AnimatorContainer::Iterator AnimatorIter;
  55 typedef AnimatorContainer::ConstIterator AnimatorConstIter;
  56
  57 /**
  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.
  60  */
  61 class AnimatorBase
  62 {
  63 public:
  64
  65   typedef float (*AlphaFunc)(float progress); ///< Definition of an alpha function
  66
  67   /**
  68    * Constructor.
  69    */
  70   AnimatorBase()
  71   : mDurationSeconds(1.0f),
  72     mInitialDelaySeconds(0.0f),
  73     mAlphaFunction(AlphaFunction::DEFAULT),
  74     mDisconnectAction(Dali::Animation::BakeFinal),
  75     mActive(false),
  76     mEnabled(true),
  77     mConnectedToSceneGraph(false)
  78   {
  79   }
  80
  81   /**
  82    * Virtual destructor.
  83    */
  84   virtual ~AnimatorBase()
  85   {
  86   }
  87
  88   /**
  89    * Called when Animator is added to the scene-graph in update-thread.
  90    */
  91   virtual void ConnectToSceneGraph() = 0;
  92
  93   /**
  94    * Set the duration of the animator.
  95    * @pre durationSeconds must be zero or greater; zero is useful when animating boolean values.
  96    * @param [in] seconds Duration in seconds.
  97    */
  98   void SetDuration(float seconds)
  99   {
 100     DALI_ASSERT_DEBUG(seconds >= 0.0f);
 101
 102     mDurationSeconds = seconds;
 103   }
 104
 105   /**
 106    * Retrieve the duration of the animator.
 107    * @return The duration in seconds.
 108    */
 109   float GetDuration()
 110   {
 111     return mDurationSeconds;
 112   }
 113
 114   /**
 115    * Set the delay before the animator should take effect.
 116    * The default is zero i.e. no delay.
 117    * @param [in] seconds The delay in seconds.
 118    */
 119   void SetInitialDelay(float seconds)
 120   {
 121     mInitialDelaySeconds = seconds;
 122   }
 123
 124   /**
 125    * Retrieve the initial delay of the animator.
 126    * @return The delay in seconds.
 127    */
 128   float GetInitialDelay()
 129   {
 130     return mInitialDelaySeconds;
 131   }
 132
 133   /**
 134    * Set the alpha function for an animator.
 135    * @param [in] alphaFunc The alpha function to apply to the animation progress.
 136    */
 137   void SetAlphaFunction(const AlphaFunction& alphaFunction)
 138   {
 139     mAlphaFunction = alphaFunction;
 140   }
 141
 142   /**
 143    * Retrieve the alpha function of an animator.
 144    * @return The function.
 145    */
 146   AlphaFunction GetAlphaFunction() const
 147   {
 148     return mAlphaFunction;
 149   }
 150
 151   /*
 152    * Applies the alpha function to the specified progress
 153    * @param[in] Current progress
 154    * @return The progress after the alpha function has been aplied
 155    */
 156   float ApplyAlphaFunction( float progress ) const
 157   {
 158     float result = progress;
 159
 160     AlphaFunction::Mode alphaFunctionMode( mAlphaFunction.GetMode() );
 161     if( alphaFunctionMode == AlphaFunction::BUILTIN_FUNCTION )
 162     {
 163       switch(mAlphaFunction.GetBuiltinFunction())
 164       {
 165         case AlphaFunction::DEFAULT:
 166         case AlphaFunction::LINEAR:
 167         {
 168           break;
 169         }
 170         case AlphaFunction::REVERSE:
 171         {
 172           result = 1.0f-progress;
 173           break;
 174         }
 175         case AlphaFunction::EASE_IN_SQUARE:
 176         {
 177           result = progress * progress;
 178           break;
 179         }
 180         case AlphaFunction::EASE_OUT_SQUARE:
 181         {
 182           result = 1.0f - (1.0f-progress) * (1.0f-progress);
 183           break;
 184         }
 185         case AlphaFunction::EASE_IN:
 186         {
 187           result = progress * progress * progress;
 188           break;
 189         }
 190         case AlphaFunction::EASE_OUT:
 191         {
 192           result = (progress-1.0f) * (progress-1.0f) * (progress-1.0f) + 1.0f;
 193           break;
 194         }
 195         case AlphaFunction::EASE_IN_OUT:
 196         {
 197           result = progress*progress*(3.0f-2.0f*progress);
 198           break;
 199         }
 200         case AlphaFunction::EASE_IN_SINE:
 201         {
 202           result = -1.0f * cosf(progress * Math::PI_2) + 1.0f;
 203           break;
 204         }
 205         case AlphaFunction::EASE_OUT_SINE:
 206         {
 207           result = sinf(progress * Math::PI_2);
 208           break;
 209         }
 210         case AlphaFunction::EASE_IN_OUT_SINE:
 211         {
 212           result = -0.5f * (cosf(Math::PI * progress) - 1.0f);
 213           break;
 214         }
 215         case AlphaFunction::BOUNCE:
 216         {
 217           result = sinf(progress * Math::PI);
 218           break;
 219         }
 220         case AlphaFunction::SIN:
 221         {
 222           result = 0.5f - cosf(progress * 2.0f * Math::PI) * 0.5f;
 223           break;
 224         }
 225         case AlphaFunction::EASE_OUT_BACK:
 226         {
 227           const float sqrt2 = 1.70158f;
 228           progress -= 1.0f;
 229           result = 1.0f + progress * progress * ( ( sqrt2 + 1.0f ) * progress + sqrt2 );
 230           break;
 231         }
 232         case AlphaFunction::COUNT:
 233         {
 234           break;
 235         }
 236       }
 237     }
 238     else if(  alphaFunctionMode == AlphaFunction::CUSTOM_FUNCTION )
 239     {
 240       AlphaFunctionPrototype customFunction = mAlphaFunction.GetCustomFunction();
 241       if( customFunction )
 242       {
 243         result = customFunction(progress);
 244       }
 245     }
 246     else
 247     {
 248       //If progress is very close to 0 or very close to 1 we don't need to evaluate the curve as the result will
 249       //be almost 0 or almost 1 respectively
 250       if( ( progress > Math::MACHINE_EPSILON_1 ) && ((1.0f - progress) > Math::MACHINE_EPSILON_1) )
 251       {
 252         Dali::Vector4 controlPoints = mAlphaFunction.GetBezierControlPoints();
 253
 254         static const float tolerance = 0.001f;  //10 iteration max
 255
 256         //Perform a binary search on the curve
 257         float lowerBound(0.0f);
 258         float upperBound(1.0f);
 259         float currentT(0.5f);
 260         float currentX = EvaluateCubicBezier( controlPoints.x, controlPoints.z, currentT);
 261         while( fabs( progress - currentX ) > tolerance )
 262         {
 263           if( progress > currentX )
 264           {
 265             lowerBound = currentT;
 266           }
 267           else
 268           {
 269             upperBound = currentT;
 270           }
 271           currentT = (upperBound+lowerBound)*0.5f;
 272           currentX = EvaluateCubicBezier( controlPoints.x, controlPoints.z, currentT);
 273         }
 274         result = EvaluateCubicBezier( controlPoints.y, controlPoints.w, currentT);
 275       }
 276     }
 277
 278     return result;
 279   }
 280
 281   /**
 282    * Whether to bake the animation if attached property owner is disconnected.
 283    * Property is only baked if the animator is active.
 284    * @param [in] action The disconnect action.
 285    */
 286   void SetDisconnectAction( Dali::Animation::EndAction action )
 287   {
 288     mDisconnectAction = action;
 289   }
 290
 291   /**
 292    * Retrieve the disconnect action of an animator.
 293    * @return The disconnect action.
 294    */
 295   Dali::Animation::EndAction GetDisconnectAction() const
 296   {
 297     return mDisconnectAction;
 298   }
 299
 300   /**
 301    * Whether the animator is active or not.
 302    * @param [in] active The new active state.
 303    * @post When the animator becomes active, it applies the disconnect-action if the property owner is then disconnected.
 304    * @note When the property owner is disconnected, the active state is set to false.
 305    */
 306   void SetActive( bool active )
 307   {
 308     mActive = active;
 309   }
 310
 311   /**
 312    * Retrieve whether the animator has been set to active or not.
 313    * @return The active state.
 314    */
 315   bool GetActive() const
 316   {
 317     return mActive;
 318   }
 319
 320   /*
 321    * Retrive wheter the animator's target object is valid and on the stage.
 322    * @return The enabled state.
 323    */
 324   bool IsEnabled() const
 325   {
 326     return mEnabled;
 327   }
 328   /**
 329    * Returns wheter the target object of the animator is still valid
 330    * or has been destroyed.
 331    * @return True if animator is orphan, false otherwise   *
 332    * @note The SceneGraph::Animation will delete any orphan animator in its Update method.
 333    */
 334   virtual bool Orphan() = 0;
 335
 336   /**
 337    * Update the scene object attached to the animator.
 338    * @param[in] bufferIndex The buffer to animate.
 339    * @param[in] progress A value from 0 to 1, where 0 is the start of the animation, and 1 is the end point.
 340    * @param[in] bake Bake.
 341    */
 342   virtual void Update(BufferIndex bufferIndex, float progress, bool bake) = 0;
 343
 344 protected:
 345
 346   /**
 347    * Helper function to evaluate a cubic bezier curve assuming first point is at 0.0 and last point is at 1.0
 348    * @param[in] p0 First control point of the bezier curve
 349    * @param[in] p1 Second control point of the bezier curve
 350    * @param[in] t A floating point value between 0.0 and 1.0
 351    * @return Value of the curve at progress t
 352    */
 353   inline float EvaluateCubicBezier( float p0, float p1, float t ) const
 354   {
 355     float tSquare = t*t;
 356     return 3.0f*(1.0f-t)*(1.0f-t)*t*p0 + 3.0f*(1.0f-t)*tSquare*p1 + tSquare*t;
 357   }
 358
 359   float mDurationSeconds;
 360   float mInitialDelaySeconds;
 361
 362   AlphaFunction mAlphaFunction;
 363
 364   Dali::Animation::EndAction mDisconnectAction;     ///< EndAction to apply when target object gets disconnected from the stage.
 365   bool mActive:1;                                   ///< Animator is "active" while it's running.
 366   bool mEnabled:1;                                  ///< Animator is "enabled" while its target object is valid and on the stage.
 367   bool mConnectedToSceneGraph:1;                    ///< True if ConnectToSceneGraph() has been called in update-thread.
 368 };
 369
 370 /**
 371  * An animator for a specific property type PropertyType.
 372  */
 373 template < typename PropertyType, typename PropertyAccessorType >
 374 class Animator : public AnimatorBase, public PropertyOwner::Observer
 375 {
 376 public:
 377
 378   /**
 379    * Construct a new property animator.
 380    * @param[in] property The animatable property; only valid while the Animator is attached.
 381    * @param[in] animatorFunction The function used to animate the property.
 382    * @param[in] alphaFunction The alpha function to apply.
 383    * @param[in] timePeriod The time period of this animation.
 384    * @return A newly allocated animator.
 385    */
 386   static AnimatorBase* New( const PropertyOwner& propertyOwner,
 387                             const PropertyBase& property,
 388                             AnimatorFunctionBase* animatorFunction,
 389                             AlphaFunction alphaFunction,
 390                             const TimePeriod& timePeriod )
 391   {
 392     typedef Animator< PropertyType, PropertyAccessorType > AnimatorType;
 393
 394     // The property was const in the actor-thread, but animators are used in the scene-graph thread.
 395     AnimatorType* animator = new AnimatorType( const_cast<PropertyOwner*>( &propertyOwner ),
 396                                                const_cast<PropertyBase*>( &property ),
 397                                                animatorFunction );
 398
 399     animator->SetAlphaFunction( alphaFunction );
 400     animator->SetInitialDelay( timePeriod.delaySeconds );
 401     animator->SetDuration( timePeriod.durationSeconds );
 402
 403     return animator;
 404   }
 405
 406   /**
 407    * Virtual destructor.
 408    */
 409   virtual ~Animator()
 410   {
 411     if (mPropertyOwner && mConnectedToSceneGraph)
 412     {
 413       mPropertyOwner->RemoveObserver(*this);
 414     }
 415
 416     delete mAnimatorFunction;
 417   }
 418
 419   /**
 420    * Called when Animator is added to the scene-graph in update-thread.
 421    */
 422   virtual void ConnectToSceneGraph()
 423   {
 424     mConnectedToSceneGraph = true;
 425     mPropertyOwner->AddObserver(*this);
 426   }
 427
 428   /**
 429    * Called when mPropertyOwner is connected to the scene graph.
 430    */
 431   virtual void PropertyOwnerConnected( PropertyOwner& owner )
 432   {
 433     mEnabled = true;
 434   }
 435
 436   /**
 437    * Called when mPropertyOwner is disconnected from the scene graph.
 438    */
 439   virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
 440   {
 441     // If we are active, then bake the value if required
 442     if ( mActive && mDisconnectAction != Dali::Animation::Discard )
 443     {
 444       // Bake to target-value if BakeFinal, otherwise bake current value
 445       Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true );
 446     }
 447
 448     mActive = false;
 449     mEnabled = false;
 450   }
 451
 452   /**
 453    * Called shortly before mPropertyOwner is destroyed
 454    */
 455   virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
 456   {
 457     mPropertyOwner = NULL;
 458   }
 459
 460   /**
 461    * From AnimatorBase.
 462    */
 463   virtual void Update( BufferIndex bufferIndex, float progress, bool bake )
 464   {
 465     float alpha = ApplyAlphaFunction(progress);
 466
 467     const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
 468
 469     const PropertyType result = (*mAnimatorFunction)( alpha, current );
 470     if ( bake )
 471     {
 472       mPropertyAccessor.Bake( bufferIndex, result );
 473     }
 474     else
 475     {
 476       mPropertyAccessor.Set( bufferIndex, result );
 477     }
 478
 479     mCurrentProgress = progress;
 480   }
 481
 482   /**
 483    * From AnimatorBase.
 484    */
 485   virtual bool Orphan()
 486   {
 487     return (mPropertyOwner == NULL);
 488   }
 489
 490 private:
 491
 492   /**
 493    * Private constructor; see also Animator::New().
 494    */
 495   Animator( PropertyOwner* propertyOwner,
 496             PropertyBase* property,
 497             AnimatorFunctionBase* animatorFunction )
 498   : mPropertyOwner( propertyOwner ),
 499     mPropertyAccessor( property ),
 500     mAnimatorFunction( animatorFunction ),
 501     mCurrentProgress( 0.0f )
 502   {
 503     // WARNING - this object is created in the event-thread
 504     // The scene-graph mPropertyOwner object cannot be observed here
 505   }
 506
 507   // Undefined
 508   Animator( const Animator& );
 509
 510   // Undefined
 511   Animator& operator=( const Animator& );
 512
 513 protected:
 514
 515   PropertyOwner* mPropertyOwner;
 516   PropertyAccessorType mPropertyAccessor;
 517
 518   AnimatorFunctionBase* mAnimatorFunction;
 519   float mCurrentProgress;
 520 };
 521
 522
 523
 524 /**
 525  * An animator for a specific property type PropertyType.
 526  */
 527 template <typename T, typename PropertyAccessorType>
 528 class AnimatorTransformProperty : public AnimatorBase, public PropertyOwner::Observer
 529 {
 530 public:
 531
 532   /**
 533    * Construct a new property animator.
 534    * @param[in] property The animatable property; only valid while the Animator is attached.
 535    * @param[in] animatorFunction The function used to animate the property.
 536    * @param[in] alphaFunction The alpha function to apply.
 537    * @param[in] timePeriod The time period of this animation.
 538    * @return A newly allocated animator.
 539    */
 540   static AnimatorBase* New( const PropertyOwner& propertyOwner,
 541                             const PropertyBase& property,
 542                             AnimatorFunctionBase* animatorFunction,
 543                             AlphaFunction alphaFunction,
 544                             const TimePeriod& timePeriod )
 545   {
 546
 547     // The property was const in the actor-thread, but animators are used in the scene-graph thread.
 548     AnimatorTransformProperty* animator = new AnimatorTransformProperty( const_cast<PropertyOwner*>( &propertyOwner ),
 549                                                const_cast<PropertyBase*>( &property ),
 550                                                animatorFunction );
 551
 552     animator->SetAlphaFunction( alphaFunction );
 553     animator->SetInitialDelay( timePeriod.delaySeconds );
 554     animator->SetDuration( timePeriod.durationSeconds );
 555
 556     return animator;
 557   }
 558
 559   /**
 560    * Virtual destructor.
 561    */
 562   virtual ~AnimatorTransformProperty()
 563   {
 564     if (mPropertyOwner && mConnectedToSceneGraph)
 565     {
 566       mPropertyOwner->RemoveObserver(*this);
 567     }
 568
 569     delete mAnimatorFunction;
 570   }
 571
 572   /**
 573    * Called when Animator is added to the scene-graph in update-thread.
 574    */
 575   virtual void ConnectToSceneGraph()
 576   {
 577     mConnectedToSceneGraph = true;
 578     mPropertyOwner->AddObserver(*this);
 579   }
 580
 581   /**
 582    * Called when mPropertyOwner is connected to the scene graph.
 583    */
 584   virtual void PropertyOwnerConnected( PropertyOwner& owner )
 585   {
 586     mEnabled = true;
 587   }
 588
 589   /**
 590    * Called when mPropertyOwner is disconnected from the scene graph.
 591    */
 592   virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
 593   {
 594     // If we are active, then bake the value if required
 595     if ( mActive && mDisconnectAction != Dali::Animation::Discard )
 596     {
 597       // Bake to target-value if BakeFinal, otherwise bake current value
 598       Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true );
 599     }
 600
 601     mActive = false;
 602     mEnabled = false;
 603   }
 604
 605   /**
 606    * Called shortly before mPropertyOwner is destroyed
 607    */
 608   virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
 609   {
 610     mPropertyOwner = NULL;
 611   }
 612
 613   /**
 614    * From AnimatorBase.
 615    */
 616   virtual void Update( BufferIndex bufferIndex, float progress, bool bake )
 617   {
 618     float alpha = ApplyAlphaFunction(progress);
 619
 620     const T& current = mPropertyAccessor.Get( bufferIndex );
 621
 622     const T result = (*mAnimatorFunction)( alpha, current );
 623
 624
 625     if ( bake )
 626     {
 627       mPropertyAccessor.Bake( bufferIndex, result );
 628     }
 629     else
 630     {
 631       mPropertyAccessor.Set( bufferIndex, result );
 632     }
 633
 634     mCurrentProgress = progress;
 635   }
 636
 637   /**
 638    * From AnimatorBase.
 639    */
 640   virtual bool Orphan()
 641   {
 642     return (mPropertyOwner == NULL);
 643   }
 644
 645 private:
 646
 647   /**
 648    * Private constructor; see also Animator::New().
 649    */
 650   AnimatorTransformProperty( PropertyOwner* propertyOwner,
 651             PropertyBase* property,
 652             AnimatorFunctionBase* animatorFunction )
 653   : mPropertyOwner( propertyOwner ),
 654     mPropertyAccessor( property ),
 655     mAnimatorFunction( animatorFunction ),
 656     mCurrentProgress( 0.0f )
 657   {
 658     // WARNING - this object is created in the event-thread
 659     // The scene-graph mPropertyOwner object cannot be observed here
 660   }
 661
 662   // Undefined
 663   AnimatorTransformProperty( const AnimatorTransformProperty& );
 664
 665   // Undefined
 666   AnimatorTransformProperty& operator=( const AnimatorTransformProperty& );
 667
 668 protected:
 669
 670   PropertyOwner* mPropertyOwner;
 671   PropertyAccessorType mPropertyAccessor;
 672
 673   AnimatorFunctionBase* mAnimatorFunction;
 674   float mCurrentProgress;
 675 };
 676
 677 } // namespace SceneGraph
 678
 679 /*
 680  * AnimatorFunction base class.
 681  * All update functions must inherit from AnimatorFunctionBase and overload the appropiate "()" operator
 682  */
 683 struct AnimatorFunctionBase
 684 {
 685   /**
 686    * Constructor
 687    */
 688   AnimatorFunctionBase(){}
 689
 690   /*
 691    * Virtual destructor (Intended as base class)
 692    */
 693   virtual ~AnimatorFunctionBase(){}
 694
 695   ///Stub "()" operators.
 696   virtual bool operator()(float progress, const bool& property)
 697   {
 698     return property;
 699   }
 700
 701   virtual float operator()(float progress, const int& property)
 702   {
 703     return property;
 704   }
 705
 706   virtual float operator()(float progress, const unsigned int& property)
 707   {
 708     return property;
 709   }
 710
 711   virtual float operator()(float progress, const float& property)
 712   {
 713     return property;
 714   }
 715
 716   virtual Vector2 operator()(float progress, const Vector2& property)
 717   {
 718     return property;
 719   }
 720
 721   virtual Vector3 operator()(float progress, const Vector3& property)
 722   {
 723     return property;
 724   }
 725
 726   virtual Vector4 operator()(float progress, const Vector4& property)
 727   {
 728     return property;
 729   }
 730
 731   virtual Quaternion operator()(float progress, const Quaternion& property)
 732   {
 733     return property;
 734   }
 735 };
 736
 737 // Update functions
 738
 739 struct AnimateByInteger : public AnimatorFunctionBase
 740 {
 741   AnimateByInteger(const int& relativeValue)
 742   : mRelative(relativeValue)
 743   {
 744   }
 745
 746   float operator()(float alpha, const int& property)
 747   {
 748     return int(property + mRelative * alpha + 0.5f );
 749   }
 750
 751   int mRelative;
 752 };
 753
 754 struct AnimateToInteger : public AnimatorFunctionBase
 755 {
 756   AnimateToInteger(const int& targetValue)
 757   : mTarget(targetValue)
 758   {
 759   }
 760
 761   float operator()(float alpha, const int& property)
 762   {
 763     return int(property + ((mTarget - property) * alpha) + 0.5f);
 764   }
 765
 766   int mTarget;
 767 };
 768
 769 struct AnimateByFloat : public AnimatorFunctionBase
 770 {
 771   AnimateByFloat(const float& relativeValue)
 772   : mRelative(relativeValue)
 773   {
 774   }
 775
 776   float operator()(float alpha, const float& property)
 777   {
 778     return float(property + mRelative * alpha);
 779   }
 780
 781   float mRelative;
 782 };
 783
 784 struct AnimateToFloat : public AnimatorFunctionBase
 785 {
 786   AnimateToFloat(const float& targetValue)
 787   : mTarget(targetValue)
 788   {
 789   }
 790
 791   float operator()(float alpha, const float& property)
 792   {
 793     return float(property + ((mTarget - property) * alpha));
 794   }
 795
 796   float mTarget;
 797 };
 798
 799 struct AnimateByVector2 : public AnimatorFunctionBase
 800 {
 801   AnimateByVector2(const Vector2& relativeValue)
 802   : mRelative(relativeValue)
 803   {
 804   }
 805
 806   Vector2 operator()(float alpha, const Vector2& property)
 807   {
 808     return Vector2(property + mRelative * alpha);
 809   }
 810
 811   Vector2 mRelative;
 812 };
 813
 814 struct AnimateToVector2 : public AnimatorFunctionBase
 815 {
 816   AnimateToVector2(const Vector2& targetValue)
 817   : mTarget(targetValue)
 818   {
 819   }
 820
 821   Vector2 operator()(float alpha, const Vector2& property)
 822   {
 823     return Vector2(property + ((mTarget - property) * alpha));
 824   }
 825
 826   Vector2 mTarget;
 827 };
 828
 829 struct AnimateByVector3 : public AnimatorFunctionBase
 830 {
 831   AnimateByVector3(const Vector3& relativeValue)
 832   : mRelative(relativeValue)
 833   {
 834   }
 835
 836   Vector3 operator()(float alpha, const Vector3& property)
 837   {
 838     return Vector3(property + mRelative * alpha);
 839   }
 840
 841   Vector3 mRelative;
 842 };
 843
 844 struct AnimateToVector3 : public AnimatorFunctionBase
 845 {
 846   AnimateToVector3(const Vector3& targetValue)
 847   : mTarget(targetValue)
 848   {
 849   }
 850
 851   Vector3 operator()(float alpha, const Vector3& property)
 852   {
 853     return Vector3(property + ((mTarget - property) * alpha));
 854   }
 855
 856   Vector3 mTarget;
 857 };
 858
 859 struct AnimateByVector4 : public AnimatorFunctionBase
 860 {
 861   AnimateByVector4(const Vector4& relativeValue)
 862   : mRelative(relativeValue)
 863   {
 864   }
 865
 866   Vector4 operator()(float alpha, const Vector4& property)
 867   {
 868     return Vector4(property + mRelative * alpha);
 869   }
 870
 871   Vector4 mRelative;
 872 };
 873
 874 struct AnimateToVector4 : public AnimatorFunctionBase
 875 {
 876   AnimateToVector4(const Vector4& targetValue)
 877   : mTarget(targetValue)
 878   {
 879   }
 880
 881   Vector4 operator()(float alpha, const Vector4& property)
 882   {
 883     return Vector4(property + ((mTarget - property) * alpha));
 884   }
 885
 886   Vector4 mTarget;
 887 };
 888
 889 struct AnimateByOpacity : public AnimatorFunctionBase
 890 {
 891   AnimateByOpacity(const float& relativeValue)
 892   : mRelative(relativeValue)
 893   {
 894   }
 895
 896   Vector4 operator()(float alpha, const Vector4& property)
 897   {
 898     Vector4 result(property);
 899     result.a += mRelative * alpha;
 900
 901     return result;
 902   }
 903
 904   float mRelative;
 905 };
 906
 907 struct AnimateToOpacity : public AnimatorFunctionBase
 908 {
 909   AnimateToOpacity(const float& targetValue)
 910   : mTarget(targetValue)
 911   {
 912   }
 913
 914   Vector4 operator()(float alpha, const Vector4& property)
 915   {
 916     Vector4 result(property);
 917     result.a = property.a + ((mTarget - property.a) * alpha);
 918
 919     return result;
 920   }
 921
 922   float mTarget;
 923 };
 924
 925 struct AnimateByBoolean : public AnimatorFunctionBase
 926 {
 927   AnimateByBoolean(bool relativeValue)
 928   : mRelative(relativeValue)
 929   {
 930   }
 931
 932   bool operator()(float alpha, const bool& property)
 933   {
 934     // Alpha is not useful here, just keeping to the same template as other update functors
 935     return bool(alpha >= 1.0f ? (property || mRelative) : property);
 936   }
 937
 938   bool mRelative;
 939 };
 940
 941 struct AnimateToBoolean : public AnimatorFunctionBase
 942 {
 943   AnimateToBoolean(bool targetValue)
 944   : mTarget(targetValue)
 945   {
 946   }
 947
 948   bool operator()(float alpha, const bool& property)
 949   {
 950     // Alpha is not useful here, just keeping to the same template as other update functors
 951     return bool(alpha >= 1.0f ? mTarget : property);
 952   }
 953
 954   bool mTarget;
 955 };
 956
 957 struct RotateByAngleAxis : public AnimatorFunctionBase
 958 {
 959   RotateByAngleAxis(const Radian& angleRadians, const Vector3& axis)
 960   : mAngleRadians( angleRadians ),
 961     mAxis(axis.x, axis.y, axis.z)
 962   {
 963   }
 964
 965   Quaternion operator()(float alpha, const Quaternion& rotation)
 966   {
 967     if (alpha > 0.0f)
 968     {
 969       return rotation * Quaternion(mAngleRadians * alpha, mAxis);
 970     }
 971
 972     return rotation;
 973   }
 974
 975   Radian mAngleRadians;
 976   Vector3 mAxis;
 977 };
 978
 979 struct RotateToQuaternion : public AnimatorFunctionBase
 980 {
 981   RotateToQuaternion(const Quaternion& targetValue)
 982   : mTarget(targetValue)
 983   {
 984   }
 985
 986   Quaternion operator()(float alpha, const Quaternion& rotation)
 987   {
 988     return Quaternion::Slerp(rotation, mTarget, alpha);
 989   }
 990
 991   Quaternion mTarget;
 992 };
 993
 994
 995 struct KeyFrameBooleanFunctor : public AnimatorFunctionBase
 996 {
 997   KeyFrameBooleanFunctor(KeyFrameBooleanPtr keyFrames)
 998   : mKeyFrames(keyFrames)
 999   {
1000   }
1001
1002   bool operator()(float progress, const bool& property)
1003   {
1004     if(mKeyFrames->IsActive(progress))
1005     {
1006       return mKeyFrames->GetValue(progress, Dali::Animation::Linear);
1007     }
1008     return property;
1009   }
1010
1011   KeyFrameBooleanPtr mKeyFrames;
1012 };
1013
1014 struct KeyFrameIntegerFunctor : public AnimatorFunctionBase
1015 {
1016   KeyFrameIntegerFunctor(KeyFrameIntegerPtr keyFrames, Interpolation interpolation)
1017   : mKeyFrames(keyFrames),mInterpolation(interpolation)
1018   {
1019   }
1020
1021   float operator()(float progress, const int& property)
1022   {
1023     if(mKeyFrames->IsActive(progress))
1024     {
1025       return mKeyFrames->GetValue(progress, mInterpolation);
1026     }
1027     return property;
1028   }
1029
1030   KeyFrameIntegerPtr mKeyFrames;
1031   Interpolation mInterpolation;
1032 };
1033
1034 struct KeyFrameNumberFunctor : public AnimatorFunctionBase
1035 {
1036   KeyFrameNumberFunctor(KeyFrameNumberPtr keyFrames, Interpolation interpolation)
1037   : mKeyFrames(keyFrames),mInterpolation(interpolation)
1038   {
1039   }
1040
1041   float operator()(float progress, const float& property)
1042   {
1043     if(mKeyFrames->IsActive(progress))
1044     {
1045       return mKeyFrames->GetValue(progress, mInterpolation);
1046     }
1047     return property;
1048   }
1049
1050   KeyFrameNumberPtr mKeyFrames;
1051   Interpolation mInterpolation;
1052 };
1053
1054 struct KeyFrameVector2Functor : public AnimatorFunctionBase
1055 {
1056   KeyFrameVector2Functor(KeyFrameVector2Ptr keyFrames, Interpolation interpolation)
1057   : mKeyFrames(keyFrames),mInterpolation(interpolation)
1058   {
1059   }
1060
1061   Vector2 operator()(float progress, const Vector2& property)
1062   {
1063     if(mKeyFrames->IsActive(progress))
1064     {
1065       return mKeyFrames->GetValue(progress, mInterpolation);
1066     }
1067     return property;
1068   }
1069
1070   KeyFrameVector2Ptr mKeyFrames;
1071   Interpolation mInterpolation;
1072 };
1073
1074
1075 struct KeyFrameVector3Functor : public AnimatorFunctionBase
1076 {
1077   KeyFrameVector3Functor(KeyFrameVector3Ptr keyFrames, Interpolation interpolation)
1078   : mKeyFrames(keyFrames),mInterpolation(interpolation)
1079   {
1080   }
1081
1082   Vector3 operator()(float progress, const Vector3& property)
1083   {
1084     if(mKeyFrames->IsActive(progress))
1085     {
1086       return mKeyFrames->GetValue(progress, mInterpolation);
1087     }
1088     return property;
1089   }
1090
1091   KeyFrameVector3Ptr mKeyFrames;
1092   Interpolation mInterpolation;
1093 };
1094
1095 struct KeyFrameVector4Functor : public AnimatorFunctionBase
1096 {
1097   KeyFrameVector4Functor(KeyFrameVector4Ptr keyFrames, Interpolation interpolation)
1098   : mKeyFrames(keyFrames),mInterpolation(interpolation)
1099   {
1100   }
1101
1102   Vector4 operator()(float progress, const Vector4& property)
1103   {
1104     if(mKeyFrames->IsActive(progress))
1105     {
1106       return mKeyFrames->GetValue(progress, mInterpolation);
1107     }
1108     return property;
1109   }
1110
1111   KeyFrameVector4Ptr mKeyFrames;
1112   Interpolation mInterpolation;
1113 };
1114
1115 struct KeyFrameQuaternionFunctor : public AnimatorFunctionBase
1116 {
1117   KeyFrameQuaternionFunctor(KeyFrameQuaternionPtr keyFrames)
1118   : mKeyFrames(keyFrames)
1119   {
1120   }
1121
1122   Quaternion operator()(float progress, const Quaternion& property)
1123   {
1124     if(mKeyFrames->IsActive(progress))
1125     {
1126       return mKeyFrames->GetValue(progress, Dali::Animation::Linear);
1127     }
1128     return property;
1129   }
1130
1131   KeyFrameQuaternionPtr mKeyFrames;
1132 };
1133
1134 struct PathPositionFunctor : public AnimatorFunctionBase
1135 {
1136   PathPositionFunctor( PathPtr path )
1137   : mPath(path)
1138   {
1139   }
1140
1141   Vector3 operator()(float progress, const Vector3& property)
1142   {
1143     Vector3 position(property);
1144     static_cast<void>( mPath->SamplePosition(progress, position) );
1145     return position;
1146   }
1147
1148   PathPtr mPath;
1149 };
1150
1151 struct PathRotationFunctor : public AnimatorFunctionBase
1152 {
1153   PathRotationFunctor( PathPtr path, const Vector3& forward )
1154   : mPath(path),
1155     mForward( forward )
1156   {
1157     mForward.Normalize();
1158   }
1159
1160   Quaternion operator()(float progress, const Quaternion& property)
1161   {
1162     Vector3 tangent;
1163     if( mPath->SampleTangent(progress, tangent) )
1164     {
1165       return Quaternion( mForward, tangent );
1166     }
1167     else
1168     {
1169       return property;
1170     }
1171   }
1172
1173   PathPtr mPath;
1174   Vector3 mForward;
1175 };
1176
1177 } // namespace Internal
1178
1179 } // namespace Dali
1180
1181 #endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__