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 // EXTERNAL INCLUDES
  22 #include <boost/function.hpp>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/internal/common/owner-container.h>
  26 #include <dali/internal/event/animation/key-frames-impl.h>
  27 #include <dali/internal/update/nodes/node.h>
  28 #include <dali/internal/update/common/property-base.h>
  29 #include <dali/internal/common/observer-pointer.h>
  30 #include <dali/public-api/animation/alpha-functions.h>
  31 #include <dali/public-api/animation/time-period.h>
  32 #include <dali/public-api/common/dali-common.h>
  33 #include <dali/public-api/math/quaternion.h>
  34 #include <dali/public-api/math/radian.h>
  35
  36 namespace Dali
  37 {
  38
  39 namespace Internal
  40 {
  41
  42 namespace SceneGraph
  43 {
  44
  45 class AnimatorBase;
  46
  47 typedef OwnerContainer< AnimatorBase* > AnimatorContainer;
  48
  49 typedef AnimatorContainer::Iterator AnimatorIter;
  50 typedef AnimatorContainer::ConstIterator AnimatorConstIter;
  51
  52 /**
  53  * An abstract base class for Animators, which can be added to scene graph animations.
  54  * Each animator changes a single property of an object in the scene graph.
  55  */
  56 class AnimatorBase
  57 {
  58 public:
  59
  60   typedef float (*AlphaFunc)(float progress); ///< Definition of an alpha function
  61
  62   /**
  63    * Constructor.
  64    */
  65   AnimatorBase()
  66   : mDurationSeconds(1.0f),
  67     mInitialDelaySeconds(0.0f),
  68     mAlphaFunc(AlphaFunctions::Linear),
  69     mRelative(false)
  70   {
  71   }
  72
  73   /**
  74    * Virtual destructor.
  75    */
  76   virtual ~AnimatorBase()
  77   {
  78   }
  79
  80   /**
  81    * Set the duration of the animator.
  82    * @pre durationSeconds must be zero or greater; zero is useful when animating boolean values.
  83    * @param [in] seconds Duration in seconds.
  84    */
  85   void SetDuration(float seconds)
  86   {
  87     DALI_ASSERT_DEBUG(seconds >= 0.0f);
  88
  89     mDurationSeconds = seconds;
  90   }
  91
  92   /**
  93    * Retrieve the duration of the animator.
  94    * @return The duration in seconds.
  95    */
  96   float GetDuration()
  97   {
  98     return mDurationSeconds;
  99   }
 100
 101   /**
 102    * Set the delay before the animator should take effect.
 103    * The default is zero i.e. no delay.
 104    * @param [in] seconds The delay in seconds.
 105    */
 106   void SetInitialDelay(float seconds)
 107   {
 108     mInitialDelaySeconds = seconds;
 109   }
 110
 111   /**
 112    * Retrieve the initial delay of the animator.
 113    * @return The delay in seconds.
 114    */
 115   float GetInitialDelay()
 116   {
 117     return mInitialDelaySeconds;
 118   }
 119
 120   /**
 121    * Set the alpha function for an animator.
 122    * @param [in] alphaFunc The alpha function to apply to the animation progress.
 123    */
 124   void SetAlphaFunc(AlphaFunc alphaFunc)
 125   {
 126     mAlphaFunc = alphaFunc;
 127   }
 128
 129   /**
 130    * Retrieve the alpha function of an animator.
 131    * @return The function.
 132    */
 133   AlphaFunc GetAlphaFunc() const
 134   {
 135     return mAlphaFunc;
 136   }
 137
 138   /**
 139    * This must be called when the animator is attached to the scene-graph.
 140    * @pre The animatable scene object must also be attached to the scene-graph.
 141    * @param[in] propertyOwner The scene-object that owns the animatable property.
 142    */
 143   virtual void Attach( PropertyOwner* propertyOwner ) = 0;
 144
 145   /**
 146    * Update the scene object attached to the animator.
 147    * @param[in] bufferIndex The buffer to animate.
 148    * @param[in] progress A value from 0 to 1, where 0 is the start of the animation, and 1 is the end point.
 149    * @param[in] bake Bake.
 150    * @return True if the update was applied, false if the animator has been orphaned.
 151    */
 152   virtual bool Update(BufferIndex bufferIndex, float progress, bool bake) = 0;
 153
 154   /**
 155    * Query whether the animator is still attached to a scene object.
 156    * The attachment will be automatically severed, when the object is destroyed.
 157    * @return True if the animator is attached.
 158    */
 159   virtual bool IsAttached() const = 0;
 160
 161 protected:
 162
 163   float mDurationSeconds;
 164   float mInitialDelaySeconds;
 165
 166   AlphaFunc mAlphaFunc;
 167
 168   bool mRelative;
 169 };
 170
 171 /**
 172  * An animator for a specific property type PropertyType.
 173  */
 174 template < typename PropertyType, typename PropertyAccessorType >
 175 class Animator : public AnimatorBase, public PropertyOwner::Observer
 176 {
 177 public:
 178
 179   typedef boost::function< PropertyType (float, const PropertyType&) > AnimatorFunction;
 180
 181   /**
 182    * Construct a new property animator.
 183    * @param[in] property The animatable property; only valid while the Animator is attached.
 184    * @param[in] animatorFunction The function used to animate the property.
 185    * @param[in] alphaFunction The alpha function to apply.
 186    * @param[in] timePeriod The time period of this animation.
 187    * @return A newly allocated animator.
 188    */
 189   static AnimatorBase* New( const PropertyBase& property,
 190                             AnimatorFunction animatorFunction,
 191                             AlphaFunction alphaFunction,
 192                             const TimePeriod& timePeriod )
 193   {
 194     typedef Animator< PropertyType, PropertyAccessorType > AnimatorType;
 195
 196     // The property was const in the actor-thread, but animators are used in the scene-graph thread.
 197     AnimatorType* animator = new AnimatorType( const_cast<PropertyBase*>( &property ),
 198                                                animatorFunction );
 199
 200     animator->SetAlphaFunc( alphaFunction );
 201     animator->SetInitialDelay( timePeriod.delaySeconds );
 202     animator->SetDuration( timePeriod.durationSeconds );
 203
 204     return animator;
 205   }
 206
 207   /**
 208    * Virtual destructor.
 209    */
 210   virtual ~Animator()
 211   {
 212     if (mPropertyOwner)
 213     {
 214       mPropertyOwner->RemoveObserver(*this);
 215     }
 216   }
 217
 218   /**
 219    * From AnimatorBase.
 220    * @param[in] propertyOwner The scene-object that owns the animatable property.
 221    */
 222   virtual void Attach( PropertyOwner* propertyOwner )
 223   {
 224     mPropertyOwner = propertyOwner;
 225
 226     if (mPropertyOwner)
 227     {
 228       mPropertyOwner->AddObserver(*this);
 229     }
 230   }
 231
 232   /**
 233    * From AnimatorBase.
 234    */
 235   virtual bool Update( BufferIndex bufferIndex, float progress, bool bake )
 236   {
 237     // If the object dies, the animator has no effect
 238     if ( mPropertyOwner )
 239     {
 240       float alpha = mAlphaFunc( progress );
 241
 242       const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
 243
 244       const PropertyType result = mAnimatorFunction( alpha, current );
 245
 246       if ( bake )
 247       {
 248         mPropertyAccessor.Bake( bufferIndex, result );
 249       }
 250       else
 251       {
 252         mPropertyAccessor.Set( bufferIndex, result );
 253       }
 254     }
 255
 256     return IsAttached(); // return false if orphaned
 257   }
 258
 259   /**
 260    * From AnimatorBase.
 261    */
 262   virtual bool IsAttached() const
 263   {
 264     return NULL != mPropertyOwner;
 265   }
 266
 267   /**
 268    * Called shortly before mPropertyOwner is destroyed, along with its property.
 269    */
 270   virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
 271   {
 272     mPropertyOwner = NULL;
 273     mPropertyAccessor.Reset();
 274   }
 275
 276 private:
 277
 278   /**
 279    * Private constructor; see also Animator::New().
 280    */
 281   Animator( PropertyBase* property,
 282             AnimatorFunction animatorFunction )
 283   : mPropertyOwner( NULL ),
 284     mPropertyAccessor( property ),
 285     mAnimatorFunction( animatorFunction )
 286   {
 287   }
 288
 289   // Undefined
 290   Animator( const Animator& );
 291
 292   // Undefined
 293   Animator& operator=( const Animator& );
 294
 295 protected:
 296
 297   PropertyOwner* mPropertyOwner;
 298   PropertyAccessorType mPropertyAccessor;
 299
 300   AnimatorFunction mAnimatorFunction;
 301 };
 302
 303 } // namespace SceneGraph
 304
 305
 306 // Common Update functions
 307
 308 struct AnimateByFloat
 309 {
 310   AnimateByFloat(const float& relativeValue)
 311   : mRelative(relativeValue)
 312   {
 313   }
 314
 315   float operator()(float alpha, const float& property)
 316   {
 317     return float(property + mRelative * alpha);
 318   }
 319
 320   float mRelative;
 321 };
 322
 323 struct AnimateToFloat
 324 {
 325   AnimateToFloat(const float& targetValue)
 326   : mTarget(targetValue)
 327   {
 328   }
 329
 330   float operator()(float alpha, const float& property)
 331   {
 332     return float(property + ((mTarget - property) * alpha));
 333   }
 334
 335   float mTarget;
 336 };
 337
 338 struct AnimateByInteger
 339 {
 340   AnimateByInteger(const int& relativeValue)
 341   : mRelative(relativeValue)
 342   {
 343   }
 344
 345   float operator()(float alpha, const int& property)
 346   {
 347     return int(property + mRelative * alpha + 0.5f );
 348   }
 349
 350   int mRelative;
 351 };
 352
 353 struct AnimateToInteger
 354 {
 355   AnimateToInteger(const int& targetValue)
 356   : mTarget(targetValue)
 357   {
 358   }
 359
 360   float operator()(float alpha, const int& property)
 361   {
 362     return int(property + ((mTarget - property) * alpha) + 0.5f);
 363   }
 364
 365   int mTarget;
 366 };
 367
 368 struct AnimateByVector2
 369 {
 370   AnimateByVector2(const Vector2& relativeValue)
 371   : mRelative(relativeValue)
 372   {
 373   }
 374
 375   Vector2 operator()(float alpha, const Vector2& property)
 376   {
 377     return Vector2(property + mRelative * alpha);
 378   }
 379
 380   Vector2 mRelative;
 381 };
 382
 383 struct AnimateToVector2
 384 {
 385   AnimateToVector2(const Vector2& targetValue)
 386   : mTarget(targetValue)
 387   {
 388   }
 389
 390   Vector2 operator()(float alpha, const Vector2& property)
 391   {
 392     return Vector2(property + ((mTarget - property) * alpha));
 393   }
 394
 395   Vector2 mTarget;
 396 };
 397
 398 struct AnimateByVector3
 399 {
 400   AnimateByVector3(const Vector3& relativeValue)
 401   : mRelative(relativeValue)
 402   {
 403   }
 404
 405   Vector3 operator()(float alpha, const Vector3& property)
 406   {
 407     return Vector3(property + mRelative * alpha);
 408   }
 409
 410   Vector3 mRelative;
 411 };
 412
 413 struct AnimateToVector3
 414 {
 415   AnimateToVector3(const Vector3& targetValue)
 416   : mTarget(targetValue)
 417   {
 418   }
 419
 420   Vector3 operator()(float alpha, const Vector3& property)
 421   {
 422     return Vector3(property + ((mTarget - property) * alpha));
 423   }
 424
 425   Vector3 mTarget;
 426 };
 427
 428 struct AnimateByVector4
 429 {
 430   AnimateByVector4(const Vector4& relativeValue)
 431   : mRelative(relativeValue)
 432   {
 433   }
 434
 435   Vector4 operator()(float alpha, const Vector4& property)
 436   {
 437     return Vector4(property + mRelative * alpha);
 438   }
 439
 440   Vector4 mRelative;
 441 };
 442
 443 struct AnimateToVector4
 444 {
 445   AnimateToVector4(const Vector4& targetValue)
 446   : mTarget(targetValue)
 447   {
 448   }
 449
 450   Vector4 operator()(float alpha, const Vector4& property)
 451   {
 452     return Vector4(property + ((mTarget - property) * alpha));
 453   }
 454
 455   Vector4 mTarget;
 456 };
 457
 458 struct AnimateByOpacity
 459 {
 460   AnimateByOpacity(const float& relativeValue)
 461   : mRelative(relativeValue)
 462   {
 463   }
 464
 465   Vector4 operator()(float alpha, const Vector4& property)
 466   {
 467     Vector4 result(property);
 468     result.a += mRelative * alpha;
 469
 470     return result;
 471   }
 472
 473   float mRelative;
 474 };
 475
 476 struct AnimateToOpacity
 477 {
 478   AnimateToOpacity(const float& targetValue)
 479   : mTarget(targetValue)
 480   {
 481   }
 482
 483   Vector4 operator()(float alpha, const Vector4& property)
 484   {
 485     Vector4 result(property);
 486     result.a = property.a + ((mTarget - property.a) * alpha);
 487
 488     return result;
 489   }
 490
 491   float mTarget;
 492 };
 493
 494 struct AnimateByBoolean
 495 {
 496   AnimateByBoolean(bool relativeValue)
 497   : mRelative(relativeValue)
 498   {
 499   }
 500
 501   bool operator()(float alpha, const bool& property)
 502   {
 503     // Alpha is not useful here, just keeping to the same template as other update functors
 504     return bool(alpha >= 1.0f ? (property || mRelative) : property);
 505   }
 506
 507   bool mRelative;
 508 };
 509
 510 struct AnimateToBoolean
 511 {
 512   AnimateToBoolean(bool targetValue)
 513   : mTarget(targetValue)
 514   {
 515   }
 516
 517   bool operator()(float alpha, const bool& property)
 518   {
 519     // Alpha is not useful here, just keeping to the same template as other update functors
 520     return bool(alpha >= 1.0f ? mTarget : property);
 521   }
 522
 523   bool mTarget;
 524 };
 525
 526 struct RotateByAngleAxis
 527 {
 528   RotateByAngleAxis(const Radian& angleRadians, const Vector3& axis)
 529   : mAngleRadians(angleRadians),
 530     mAxis(axis.x, axis.y, axis.z, 0.0f)
 531   {
 532   }
 533
 534   Quaternion operator()(float alpha, const Quaternion& rotation)
 535   {
 536     if (alpha > 0.0f)
 537     {
 538       return rotation * Quaternion(mAngleRadians * alpha, mAxis);
 539     }
 540
 541     return rotation;
 542   }
 543
 544   float mAngleRadians;
 545   Vector4 mAxis;
 546 };
 547
 548 struct RotateToQuaternion
 549 {
 550   RotateToQuaternion(const Quaternion& targetValue)
 551   : mTarget(targetValue)
 552   {
 553   }
 554
 555   Quaternion operator()(float alpha, const Quaternion& rotation)
 556   {
 557     return Quaternion::Slerp(rotation, mTarget, alpha);
 558   }
 559
 560   Quaternion mTarget;
 561 };
 562
 563
 564 struct KeyFrameBooleanFunctor
 565 {
 566   KeyFrameBooleanFunctor(KeyFrameBooleanPtr keyFrames)
 567   : mKeyFrames(keyFrames)
 568   {
 569   }
 570
 571   bool operator()(float progress, const bool& property)
 572   {
 573     if(mKeyFrames->IsActive(progress))
 574     {
 575       return mKeyFrames->GetValue(progress);
 576     }
 577     return property;
 578   }
 579
 580   KeyFrameBooleanPtr mKeyFrames;
 581 };
 582
 583 struct KeyFrameNumberFunctor
 584 {
 585   KeyFrameNumberFunctor(KeyFrameNumberPtr keyFrames)
 586   : mKeyFrames(keyFrames)
 587   {
 588   }
 589
 590   float operator()(float progress, const float& property)
 591   {
 592     if(mKeyFrames->IsActive(progress))
 593     {
 594       return mKeyFrames->GetValue(progress);
 595     }
 596     return property;
 597   }
 598
 599   KeyFrameNumberPtr mKeyFrames;
 600 };
 601
 602 struct KeyFrameIntegerFunctor
 603 {
 604   KeyFrameIntegerFunctor(KeyFrameIntegerPtr keyFrames)
 605   : mKeyFrames(keyFrames)
 606   {
 607   }
 608
 609   float operator()(float progress, const int& property)
 610   {
 611     if(mKeyFrames->IsActive(progress))
 612     {
 613       return mKeyFrames->GetValue(progress);
 614     }
 615     return property;
 616   }
 617
 618   KeyFrameIntegerPtr mKeyFrames;
 619 };
 620
 621 struct KeyFrameVector2Functor
 622 {
 623   KeyFrameVector2Functor(KeyFrameVector2Ptr keyFrames)
 624   : mKeyFrames(keyFrames)
 625   {
 626   }
 627
 628   Vector2 operator()(float progress, const Vector2& property)
 629   {
 630     if(mKeyFrames->IsActive(progress))
 631     {
 632       return mKeyFrames->GetValue(progress);
 633     }
 634     return property;
 635   }
 636
 637   KeyFrameVector2Ptr mKeyFrames;
 638 };
 639
 640
 641 struct KeyFrameVector3Functor
 642 {
 643   KeyFrameVector3Functor(KeyFrameVector3Ptr keyFrames)
 644   : mKeyFrames(keyFrames)
 645   {
 646   }
 647
 648   Vector3 operator()(float progress, const Vector3& property)
 649   {
 650     if(mKeyFrames->IsActive(progress))
 651     {
 652       return mKeyFrames->GetValue(progress);
 653     }
 654     return property;
 655   }
 656
 657   KeyFrameVector3Ptr mKeyFrames;
 658 };
 659
 660 struct KeyFrameVector4Functor
 661 {
 662   KeyFrameVector4Functor(KeyFrameVector4Ptr keyFrames)
 663   : mKeyFrames(keyFrames)
 664   {
 665   }
 666
 667   Vector4 operator()(float progress, const Vector4& property)
 668   {
 669     if(mKeyFrames->IsActive(progress))
 670     {
 671       return mKeyFrames->GetValue(progress);
 672     }
 673     return property;
 674   }
 675
 676   KeyFrameVector4Ptr mKeyFrames;
 677 };
 678
 679 struct KeyFrameQuaternionFunctor
 680 {
 681   KeyFrameQuaternionFunctor(KeyFrameQuaternionPtr keyFrames)
 682   : mKeyFrames(keyFrames)
 683   {
 684   }
 685
 686   Quaternion operator()(float progress, const Quaternion& property)
 687   {
 688     if(mKeyFrames->IsActive(progress))
 689     {
 690       return mKeyFrames->GetValue(progress);
 691     }
 692     return property;
 693   }
 694
 695   KeyFrameQuaternionPtr mKeyFrames;
 696 };
 697
 698
 699
 700
 701 } // namespace Internal
 702
 703 } // namespace Dali
 704
 705 #endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__