X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fanimation%2Fscene-graph-animator.h;h=cbf0842ad713b758ae12f07d7bd8f1fedddf952a;hb=db9cfcd683be8e4b3a1f83f6378e493770eb9533;hp=ae18f067f6341f017611aee68b142ab1d0f53625;hpb=c114bfe4714e8f02c54b25e381a41d80bdcb2d93;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/animation/scene-graph-animator.h b/dali/internal/update/animation/scene-graph-animator.h old mode 100644 new mode 100755 index ae18f06..cbf0842 --- a/dali/internal/update/animation/scene-graph-animator.h +++ b/dali/internal/update/animation/scene-graph-animator.h @@ -1,8 +1,8 @@ -#ifndef __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__ -#define __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__ +#ifndef DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H +#define DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H /* - * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * Copyright (c) 2019 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,6 +18,9 @@ * */ +// EXTERNAL INCLUDES +#include + // INTERNAL INCLUDES #include #include @@ -40,29 +43,74 @@ namespace Dali namespace Internal { -typedef Dali::Animation::Interpolation Interpolation; - -struct AnimatorFunctionBase; +using Interpolation = Dali::Animation::Interpolation; -namespace SceneGraph +/** + * AnimatorFunction base class. + * Needs to be declared first so AnimatorBase knows about it's destructor + * All update functions must inherit from AnimatorFunctionBase and overload the appropiate "()" operator + */ +struct AnimatorFunctionBase { + /** + * Constructor + */ + AnimatorFunctionBase() {} + + /* + * Virtual destructor (Intended as base class) + */ + virtual ~AnimatorFunctionBase() {} + + ///Stub "()" operators. + virtual bool operator()(float progress, const bool& property) + { + return property; + } + + virtual float operator()(float progress, const int32_t& property) + { + return static_cast( property ); + } + + virtual float operator()(float progress, const float& property) + { + return property; + } + + virtual Vector2 operator()(float progress, const Vector2& property) + { + return property; + } -class AnimatorBase; + virtual Vector3 operator()(float progress, const Vector3& property) + { + return property; + } + + virtual Vector4 operator()(float progress, const Vector4& property) + { + return property; + } -typedef OwnerContainer< AnimatorBase* > AnimatorContainer; + virtual Quaternion operator()(float progress, const Quaternion& property) + { + return property; + } +}; -typedef AnimatorContainer::Iterator AnimatorIter; -typedef AnimatorContainer::ConstIterator AnimatorConstIter; +namespace SceneGraph +{ /** * An abstract base class for Animators, which can be added to scene graph animations. * Each animator changes a single property of an object in the scene graph. */ -class AnimatorBase +class AnimatorBase : public PropertyOwner::Observer { public: - typedef float (*AlphaFunc)(float progress); ///< Definition of an alpha function + using AlphaFunc = float (*)(float progress); ///< Definition of an alpha function /** * Observer to determine when the animator is no longer present @@ -86,17 +134,23 @@ public: /** * Constructor. */ - AnimatorBase() - : mLifecycleObserver(nullptr), - mDurationSeconds(1.0f), - mIntervalDelaySeconds(0.0f), - mSpeedFactor(1.0f), - mLoopCount(1), - mAlphaFunction(AlphaFunction::DEFAULT), - mDisconnectAction(Dali::Animation::BakeFinal), - mAnimationPlaying(false), - mEnabled(true), - mConnectedToSceneGraph(false), + AnimatorBase( PropertyOwner* propertyOwner, + AnimatorFunctionBase* animatorFunction, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod ) + : mLifecycleObserver( nullptr ), + mPropertyOwner( propertyOwner ), + mAnimatorFunction( animatorFunction ), + mDurationSeconds( timePeriod.durationSeconds ), + mIntervalDelaySeconds( timePeriod.delaySeconds ), + mSpeedFactor( 1.0f ), + mCurrentProgress( 0.f ), + mLoopCount( 1 ), + mAlphaFunction( alphaFunction ), + mDisconnectAction( Dali::Animation::BakeFinal ), + mAnimationPlaying( false ), + mEnabled( true ), + mConnectedToSceneGraph( false ), mAutoReverseEnabled( false ) { } @@ -106,6 +160,11 @@ public: */ virtual ~AnimatorBase() { + delete mAnimatorFunction; + if (mPropertyOwner && mConnectedToSceneGraph) + { + mPropertyOwner->RemoveObserver(*this); + } if( mLifecycleObserver != nullptr ) { mLifecycleObserver->ObjectDestroyed(); @@ -122,10 +181,48 @@ public: mLifecycleObserver = nullptr; } +private: // From PropertyOwner::Observer + + /** + * @copydoc PropertyOwner::Observer::PropertyOwnerConnected( PropertyOwner& owner ) + */ + void PropertyOwnerConnected( PropertyOwner& owner ) override final + { + mEnabled = true; + } + + /** + * @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) + */ + void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override final + { + // If we are active, then bake the value if required + if ( mAnimationPlaying && mDisconnectAction != Dali::Animation::Discard ) + { + // Bake to target-value if BakeFinal, otherwise bake current value + Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true ); + } + + mEnabled = false; + } + + /** + * @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed( PropertyOwner& owner ) + */ + void PropertyOwnerDestroyed( PropertyOwner& owner ) override final + { + mPropertyOwner = nullptr; + } + +public: /** * Called when Animator is added to the scene-graph in update-thread. */ - virtual void ConnectToSceneGraph() = 0; + void ConnectToSceneGraph() + { + mConnectedToSceneGraph = true; + mPropertyOwner->AddObserver(*this); + } /** * Set the duration of the animator. @@ -380,7 +477,7 @@ public: } /** - * Retrive wheter the animator's target object is valid and on the stage. + * Whether the animator's target object is valid and on the stage. * @return The enabled state. */ bool IsEnabled() const @@ -403,7 +500,10 @@ public: * @return True if animator is orphan, false otherwise * * @note The SceneGraph::Animation will delete any orphan animator in its Update method. */ - virtual bool Orphan() = 0; + bool Orphan() + { + return (mPropertyOwner == nullptr); + } /** * Update the scene object attached to the animator. @@ -411,7 +511,34 @@ public: * @param[in] progress A value from 0 to 1, where 0 is the start of the animation, and 1 is the end point. * @param[in] bake Bake. */ - virtual void Update(BufferIndex bufferIndex, float progress, bool bake) = 0; + void Update( BufferIndex bufferIndex, float progress, bool bake ) + { + if( mLoopCount >= 0 ) + { + // Update the progress value + progress = SetProgress( progress ); + } + + if( mPropertyOwner ) + { + mPropertyOwner->SetPropertyDirty( true ); + } + + float alpha = ApplyAlphaFunction( progress ); + + // PropertyType specific part + DoUpdate( bufferIndex, bake, alpha ); + + mCurrentProgress = progress; + } + + /** + * Type specific part of the animator + * @param bufferIndex index to use + * @param bake whether to bake or not + * @param alpha value from alpha based on progress + */ + virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) = 0; protected: @@ -429,9 +556,12 @@ protected: } LifecycleObserver* mLifecycleObserver; + PropertyOwner* mPropertyOwner; + AnimatorFunctionBase* mAnimatorFunction; float mDurationSeconds; float mIntervalDelaySeconds; float mSpeedFactor; + float mCurrentProgress; int32_t mLoopCount; @@ -448,7 +578,7 @@ protected: * An animator for a specific property type PropertyType. */ template < typename PropertyType, typename PropertyAccessorType > -class Animator : public AnimatorBase, public PropertyOwner::Observer +class Animator : public AnimatorBase { public: @@ -466,18 +596,12 @@ public: AlphaFunction alphaFunction, const TimePeriod& timePeriod ) { - typedef Animator< PropertyType, PropertyAccessorType > AnimatorType; - // The property was const in the actor-thread, but animators are used in the scene-graph thread. - AnimatorType* animator = new AnimatorType( const_cast( &propertyOwner ), - const_cast( &property ), - animatorFunction ); - - animator->SetAlphaFunction( alphaFunction ); - animator->SetIntervalDelay( timePeriod.delaySeconds ); - animator->SetDuration( timePeriod.durationSeconds ); - - return animator; + return new Animator( const_cast( &propertyOwner ), + const_cast( &property ), + animatorFunction, + alphaFunction, + timePeriod ); } /** @@ -485,71 +609,18 @@ public: */ virtual ~Animator() { - if (mPropertyOwner && mConnectedToSceneGraph) - { - mPropertyOwner->RemoveObserver(*this); - } - - delete mAnimatorFunction; - } - - /** - * Called when Animator is added to the scene-graph in update-thread. - */ - virtual void ConnectToSceneGraph() - { - mConnectedToSceneGraph = true; - mPropertyOwner->AddObserver(*this); - } - - /** - * Called when mPropertyOwner is connected to the scene graph. - */ - virtual void PropertyOwnerConnected( PropertyOwner& owner ) - { - mEnabled = true; - } - - /** - * Called when mPropertyOwner is disconnected from the scene graph. - */ - virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) - { - // If we are active, then bake the value if required - if ( mAnimationPlaying && mDisconnectAction != Dali::Animation::Discard ) - { - // Bake to target-value if BakeFinal, otherwise bake current value - Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true ); - } - - mEnabled = false; - } - - /** - * Called shortly before mPropertyOwner is destroyed - */ - virtual void PropertyOwnerDestroyed( PropertyOwner& owner ) - { - mPropertyOwner = NULL; } /** - * From AnimatorBase. + * @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) */ - virtual void Update( BufferIndex bufferIndex, float progress, bool bake ) + virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) override final { - if( mLoopCount >= 0 ) - { - // Update the progress value - progress = SetProgress( progress ); - } - - float alpha = ApplyAlphaFunction( progress ); - const PropertyType& current = mPropertyAccessor.Get( bufferIndex ); // need to cast the return value in case property is integer const PropertyType result = static_cast( (*mAnimatorFunction)( alpha, current ) ); + if ( bake ) { mPropertyAccessor.Bake( bufferIndex, result ); @@ -558,16 +629,6 @@ public: { mPropertyAccessor.Set( bufferIndex, result ); } - - mCurrentProgress = progress; - } - - /** - * From AnimatorBase. - */ - virtual bool Orphan() - { - return (mPropertyOwner == NULL); } private: @@ -577,11 +638,11 @@ private: */ Animator( PropertyOwner* propertyOwner, PropertyBase* property, - AnimatorFunctionBase* animatorFunction ) - : mPropertyOwner( propertyOwner ), - mPropertyAccessor( property ), - mAnimatorFunction( animatorFunction ), - mCurrentProgress( 0.0f ) + AnimatorFunctionBase* animatorFunction, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod ) + : AnimatorBase( propertyOwner, animatorFunction, alphaFunction, timePeriod ), + mPropertyAccessor( property ) { // WARNING - this object is created in the event-thread // The scene-graph mPropertyOwner object cannot be observed here @@ -595,11 +656,8 @@ private: protected: - PropertyOwner* mPropertyOwner; PropertyAccessorType mPropertyAccessor; - AnimatorFunctionBase* mAnimatorFunction; - float mCurrentProgress; }; @@ -607,8 +665,8 @@ protected: /** * An animator for a specific property type PropertyType. */ -template -class AnimatorTransformProperty : public AnimatorBase, public PropertyOwner::Observer +template +class AnimatorTransformProperty : public AnimatorBase { public: @@ -628,15 +686,11 @@ public: { // The property was const in the actor-thread, but animators are used in the scene-graph thread. - AnimatorTransformProperty* animator = new AnimatorTransformProperty( const_cast( &propertyOwner ), - const_cast( &property ), - animatorFunction ); - - animator->SetAlphaFunction( alphaFunction ); - animator->SetIntervalDelay( timePeriod.delaySeconds ); - animator->SetDuration( timePeriod.durationSeconds ); - - return animator; + return new AnimatorTransformProperty( const_cast( &propertyOwner ), + const_cast( &property ), + animatorFunction, + alphaFunction, + timePeriod ); } /** @@ -644,71 +698,17 @@ public: */ virtual ~AnimatorTransformProperty() { - if (mPropertyOwner && mConnectedToSceneGraph) - { - mPropertyOwner->RemoveObserver(*this); - } - - delete mAnimatorFunction; - } - - /** - * Called when Animator is added to the scene-graph in update-thread. - */ - virtual void ConnectToSceneGraph() - { - mConnectedToSceneGraph = true; - mPropertyOwner->AddObserver(*this); - } - - /** - * Called when mPropertyOwner is connected to the scene graph. - */ - virtual void PropertyOwnerConnected( PropertyOwner& owner ) - { - mEnabled = true; - } - - /** - * Called when mPropertyOwner is disconnected from the scene graph. - */ - virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) - { - // If we are active, then bake the value if required - if ( mAnimationPlaying && mDisconnectAction != Dali::Animation::Discard ) - { - // Bake to target-value if BakeFinal, otherwise bake current value - Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true ); - } - - mEnabled = false; - } - - /** - * Called shortly before mPropertyOwner is destroyed - */ - virtual void PropertyOwnerDestroyed( PropertyOwner& owner ) - { - mPropertyOwner = NULL; } /** - * From AnimatorBase. + * @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) */ - virtual void Update( BufferIndex bufferIndex, float progress, bool bake ) + virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) override final { - if( mLoopCount >= 0 ) - { - // Update the progress value - progress = SetProgress( progress ); - } - - float alpha = ApplyAlphaFunction( progress ); - - const T& current = mPropertyAccessor.Get( bufferIndex ); + const PropertyType& current = mPropertyAccessor.Get( bufferIndex ); // need to cast the return value in case property is integer - T result = static_cast( (*mAnimatorFunction)( alpha, current ) ); + const PropertyType result = static_cast( (*mAnimatorFunction)( alpha, current ) ); if ( bake ) { @@ -718,16 +718,6 @@ public: { mPropertyAccessor.Set( bufferIndex, result ); } - - mCurrentProgress = progress; - } - - /** - * From AnimatorBase. - */ - virtual bool Orphan() - { - return (mPropertyOwner == NULL); } private: @@ -737,86 +727,29 @@ private: */ AnimatorTransformProperty( PropertyOwner* propertyOwner, PropertyBase* property, - AnimatorFunctionBase* animatorFunction ) - : mPropertyOwner( propertyOwner ), - mPropertyAccessor( property ), - mAnimatorFunction( animatorFunction ), - mCurrentProgress( 0.0f ) + AnimatorFunctionBase* animatorFunction, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod ) + : AnimatorBase( propertyOwner, animatorFunction, alphaFunction, timePeriod ), + mPropertyAccessor( property ) { // WARNING - this object is created in the event-thread // The scene-graph mPropertyOwner object cannot be observed here } // Undefined - AnimatorTransformProperty( const AnimatorTransformProperty& ); - - // Undefined - AnimatorTransformProperty& operator=( const AnimatorTransformProperty& ); + AnimatorTransformProperty() = delete; + AnimatorTransformProperty( const AnimatorTransformProperty& ) = delete; + AnimatorTransformProperty& operator=( const AnimatorTransformProperty& ) = delete; protected: - PropertyOwner* mPropertyOwner; PropertyAccessorType mPropertyAccessor; - AnimatorFunctionBase* mAnimatorFunction; - float mCurrentProgress; }; } // namespace SceneGraph -/* - * AnimatorFunction base class. - * All update functions must inherit from AnimatorFunctionBase and overload the appropiate "()" operator - */ -struct AnimatorFunctionBase -{ - /** - * Constructor - */ - AnimatorFunctionBase(){} - - /* - * Virtual destructor (Intended as base class) - */ - virtual ~AnimatorFunctionBase(){} - - ///Stub "()" operators. - virtual bool operator()(float progress, const bool& property) - { - return property; - } - - virtual float operator()(float progress, const int32_t& property) - { - return static_cast( property ); - } - - virtual float operator()(float progress, const float& property) - { - return property; - } - - virtual Vector2 operator()(float progress, const Vector2& property) - { - return property; - } - - virtual Vector3 operator()(float progress, const Vector3& property) - { - return property; - } - - virtual Vector4 operator()(float progress, const Vector4& property) - { - return property; - } - - virtual Quaternion operator()(float progress, const Quaternion& property) - { - return property; - } -}; - // Update functions struct AnimateByInteger : public AnimatorFunctionBase @@ -1288,4 +1221,4 @@ struct PathRotationFunctor : public AnimatorFunctionBase } // namespace Dali -#endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__ +#endif // DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H