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