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 AnimateByVector2
 339 {
 340   AnimateByVector2(const Vector2& relativeValue)
 341   : mRelative(relativeValue)
 342   {
 343   }
 344
 345   Vector2 operator()(float alpha, const Vector2& property)
 346   {
 347     return Vector2(property + mRelative * alpha);
 348   }
 349
 350   Vector2 mRelative;
 351 };
 352
 353 struct AnimateToVector2
 354 {
 355   AnimateToVector2(const Vector2& targetValue)
 356   : mTarget(targetValue)
 357   {
 358   }
 359
 360   Vector2 operator()(float alpha, const Vector2& property)
 361   {
 362     return Vector2(property + ((mTarget - property) * alpha));
 363   }
 364
 365   Vector2 mTarget;
 366 };
 367
 368 struct AnimateByVector3
 369 {
 370   AnimateByVector3(const Vector3& relativeValue)
 371   : mRelative(relativeValue)
 372   {
 373   }
 374
 375   Vector3 operator()(float alpha, const Vector3& property)
 376   {
 377     return Vector3(property + mRelative * alpha);
 378   }
 379
 380   Vector3 mRelative;
 381 };
 382
 383 struct AnimateToVector3
 384 {
 385   AnimateToVector3(const Vector3& targetValue)
 386   : mTarget(targetValue)
 387   {
 388   }
 389
 390   Vector3 operator()(float alpha, const Vector3& property)
 391   {
 392     return Vector3(property + ((mTarget - property) * alpha));
 393   }
 394
 395   Vector3 mTarget;
 396 };
 397
 398 struct AnimateByVector4
 399 {
 400   AnimateByVector4(const Vector4& relativeValue)
 401   : mRelative(relativeValue)
 402   {
 403   }
 404
 405   Vector4 operator()(float alpha, const Vector4& property)
 406   {
 407     return Vector4(property + mRelative * alpha);
 408   }
 409
 410   Vector4 mRelative;
 411 };
 412
 413 struct AnimateToVector4
 414 {
 415   AnimateToVector4(const Vector4& targetValue)
 416   : mTarget(targetValue)
 417   {
 418   }
 419
 420   Vector4 operator()(float alpha, const Vector4& property)
 421   {
 422     return Vector4(property + ((mTarget - property) * alpha));
 423   }
 424
 425   Vector4 mTarget;
 426 };
 427
 428 struct AnimateByOpacity
 429 {
 430   AnimateByOpacity(const float& relativeValue)
 431   : mRelative(relativeValue)
 432   {
 433   }
 434
 435   Vector4 operator()(float alpha, const Vector4& property)
 436   {
 437     Vector4 result(property);
 438     result.a += mRelative * alpha;
 439
 440     return result;
 441   }
 442
 443   float mRelative;
 444 };
 445
 446 struct AnimateToOpacity
 447 {
 448   AnimateToOpacity(const float& targetValue)
 449   : mTarget(targetValue)
 450   {
 451   }
 452
 453   Vector4 operator()(float alpha, const Vector4& property)
 454   {
 455     Vector4 result(property);
 456     result.a = property.a + ((mTarget - property.a) * alpha);
 457
 458     return result;
 459   }
 460
 461   float mTarget;
 462 };
 463
 464 struct AnimateByBoolean
 465 {
 466   AnimateByBoolean(bool relativeValue)
 467   : mRelative(relativeValue)
 468   {
 469   }
 470
 471   bool operator()(float alpha, const bool& property)
 472   {
 473     // Alpha is not useful here, just keeping to the same template as other update functors
 474     return bool(alpha >= 1.0f ? (property || mRelative) : property);
 475   }
 476
 477   bool mRelative;
 478 };
 479
 480 struct AnimateToBoolean
 481 {
 482   AnimateToBoolean(bool targetValue)
 483   : mTarget(targetValue)
 484   {
 485   }
 486
 487   bool operator()(float alpha, const bool& property)
 488   {
 489     // Alpha is not useful here, just keeping to the same template as other update functors
 490     return bool(alpha >= 1.0f ? mTarget : property);
 491   }
 492
 493   bool mTarget;
 494 };
 495
 496 struct RotateByAngleAxis
 497 {
 498   RotateByAngleAxis(const Radian& angleRadians, const Vector3& axis)
 499   : mAngleRadians(angleRadians),
 500     mAxis(axis.x, axis.y, axis.z, 0.0f)
 501   {
 502   }
 503
 504   Quaternion operator()(float alpha, const Quaternion& rotation)
 505   {
 506     if (alpha > 0.0f)
 507     {
 508       return rotation * Quaternion(mAngleRadians * alpha, mAxis);
 509     }
 510
 511     return rotation;
 512   }
 513
 514   float mAngleRadians;
 515   Vector4 mAxis;
 516 };
 517
 518 struct RotateToQuaternion
 519 {
 520   RotateToQuaternion(const Quaternion& targetValue)
 521   : mTarget(targetValue)
 522   {
 523   }
 524
 525   Quaternion operator()(float alpha, const Quaternion& rotation)
 526   {
 527     return Quaternion::Slerp(rotation, mTarget, alpha);
 528   }
 529
 530   Quaternion mTarget;
 531 };
 532
 533
 534 struct KeyFrameBooleanFunctor
 535 {
 536   KeyFrameBooleanFunctor(KeyFrameBooleanPtr keyFrames)
 537   : mKeyFrames(keyFrames)
 538   {
 539   }
 540
 541   bool operator()(float progress, const bool& property)
 542   {
 543     if(mKeyFrames->IsActive(progress))
 544     {
 545       return mKeyFrames->GetValue(progress);
 546     }
 547     return property;
 548   }
 549
 550   KeyFrameBooleanPtr mKeyFrames;
 551 };
 552
 553 struct KeyFrameNumberFunctor
 554 {
 555   KeyFrameNumberFunctor(KeyFrameNumberPtr keyFrames)
 556   : mKeyFrames(keyFrames)
 557   {
 558   }
 559
 560   float operator()(float progress, const float& property)
 561   {
 562     if(mKeyFrames->IsActive(progress))
 563     {
 564       return mKeyFrames->GetValue(progress);
 565     }
 566     return property;
 567   }
 568
 569   KeyFrameNumberPtr mKeyFrames;
 570 };
 571
 572 struct KeyFrameVector2Functor
 573 {
 574   KeyFrameVector2Functor(KeyFrameVector2Ptr keyFrames)
 575   : mKeyFrames(keyFrames)
 576   {
 577   }
 578
 579   Vector2 operator()(float progress, const Vector2& property)
 580   {
 581     if(mKeyFrames->IsActive(progress))
 582     {
 583       return mKeyFrames->GetValue(progress);
 584     }
 585     return property;
 586   }
 587
 588   KeyFrameVector2Ptr mKeyFrames;
 589 };
 590
 591
 592 struct KeyFrameVector3Functor
 593 {
 594   KeyFrameVector3Functor(KeyFrameVector3Ptr keyFrames)
 595   : mKeyFrames(keyFrames)
 596   {
 597   }
 598
 599   Vector3 operator()(float progress, const Vector3& property)
 600   {
 601     if(mKeyFrames->IsActive(progress))
 602     {
 603       return mKeyFrames->GetValue(progress);
 604     }
 605     return property;
 606   }
 607
 608   KeyFrameVector3Ptr mKeyFrames;
 609 };
 610
 611 struct KeyFrameVector4Functor
 612 {
 613   KeyFrameVector4Functor(KeyFrameVector4Ptr keyFrames)
 614   : mKeyFrames(keyFrames)
 615   {
 616   }
 617
 618   Vector4 operator()(float progress, const Vector4& property)
 619   {
 620     if(mKeyFrames->IsActive(progress))
 621     {
 622       return mKeyFrames->GetValue(progress);
 623     }
 624     return property;
 625   }
 626
 627   KeyFrameVector4Ptr mKeyFrames;
 628 };
 629
 630 struct KeyFrameQuaternionFunctor
 631 {
 632   KeyFrameQuaternionFunctor(KeyFrameQuaternionPtr keyFrames)
 633   : mKeyFrames(keyFrames)
 634   {
 635   }
 636
 637   Quaternion operator()(float progress, const Quaternion& property)
 638   {
 639     if(mKeyFrames->IsActive(progress))
 640     {
 641       return mKeyFrames->GetValue(progress);
 642     }
 643     return property;
 644   }
 645
 646   KeyFrameQuaternionPtr mKeyFrames;
 647 };
 648
 649
 650
 651
 652 } // namespace Internal
 653
 654 } // namespace Dali
 655
 656 #endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__