X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fanimation%2Fscene-graph-animator.h;h=391bacfb1feb090a480393393e5966b5325395d7;hb=1fdfbc2906bc1dcae714eedfbe6c7f94cd6f9364;hp=b8da716b87f3eaf6dc78b489a044881e80180cca;hpb=b3898fbb1337f5d33559a4b953ed75483461d7ca;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 index b8da716..391bacf 100644 --- 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) 2023 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,12 +18,16 @@ * */ +// EXTERNAL INCLUDES +#include +#include + // INTERNAL INCLUDES -#include #include #include -#include +#include #include +#include #include #include #include @@ -31,38 +35,23 @@ #include #include #include -#include -#include namespace Dali { - namespace Internal { - -typedef Dali::Animation::Interpolation Interpolation; - -struct AnimatorFunctionBase; +using Interpolation = Dali::Animation::Interpolation; namespace SceneGraph { - -class AnimatorBase; - -typedef OwnerContainer< AnimatorBase* > AnimatorContainer; - -typedef AnimatorContainer::Iterator AnimatorIter; -typedef AnimatorContainer::ConstIterator AnimatorConstIter; - /** * 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 @@ -82,50 +71,96 @@ public: virtual ~LifecycleObserver() = default; }; - /** * Constructor. */ - AnimatorBase() + AnimatorBase(PropertyOwner* propertyOwner, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod) : mLifecycleObserver(nullptr), - mDurationSeconds(1.0f), - mIntervalDelaySeconds(0.0f), + mPropertyOwner(propertyOwner), + mDurationSeconds(timePeriod.durationSeconds), + mIntervalDelaySeconds(timePeriod.delaySeconds), mSpeedFactor(1.0f), - mLoopCount(1), - mAlphaFunction(AlphaFunction::DEFAULT), - mDisconnectAction(Dali::Animation::BakeFinal), - mActive(false), + mCurrentProgress(0.f), + mAlphaFunction(alphaFunction), + mDisconnectAction(Dali::Animation::BAKE_FINAL), + mAnimationPlaying(false), mEnabled(true), mConnectedToSceneGraph(false), - mAutoReverseEnabled( false ) + mAutoReverseEnabled(false) { } /** * Virtual destructor. */ - virtual ~AnimatorBase() + ~AnimatorBase() override { - if( mLifecycleObserver != nullptr ) + if(mPropertyOwner && mConnectedToSceneGraph) + { + mPropertyOwner->RemoveObserver(*this); + } + if(mLifecycleObserver != nullptr) { mLifecycleObserver->ObjectDestroyed(); } } - void AddLifecycleObserver( LifecycleObserver& observer ) + void AddLifecycleObserver(LifecycleObserver& observer) { mLifecycleObserver = &observer; } - void RemoveLifecycleObserver( LifecycleObserver& observer ) + void RemoveLifecycleObserver(LifecycleObserver& observer) { mLifecycleObserver = nullptr; } +private: // From PropertyOwner::Observer + /** + * @copydoc PropertyOwner::Observer::PropertyOwnerConnected( PropertyOwner& owner ) + */ + void PropertyOwnerConnected(PropertyOwner& owner) final + { + mEnabled = true; + } + + /** + * @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) + */ + void PropertyOwnerDisconnected(BufferIndex bufferIndex, PropertyOwner& owner) 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) 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); + + // Enable if the target object is valid and connected to the scene graph. + mEnabled = mPropertyOwner->IsAnimationPossible(); + } /** * Set the duration of the animator. @@ -148,30 +183,30 @@ public: return mDurationSeconds; } - void SetSpeedFactor( float factor ) + void SetSpeedFactor(float factor) { mSpeedFactor = factor; } - void SetLoopCount(int loopCount) + void SetLoopCount(int32_t loopCount) { mLoopCount = loopCount; } - float SetProgress( float progress ) + float SetProgress(float progress) { float value = 0.0f; - if( mAutoReverseEnabled ) + if(mAutoReverseEnabled) { - if( mSpeedFactor > 0.0f ) + if(mSpeedFactor > 0.0f) { - value = 1.0f - 2.0f * std::abs( progress - 0.5f ); + value = 1.0f - 2.0f * std::abs(progress - 0.5f); } // Reverse mode - else if( mSpeedFactor < 0.0f ) + else if(mSpeedFactor < 0.0f) { - value = 2.0f * std::abs( progress - 0.5f ); + value = 2.0f * std::abs(progress - 0.5f); } } else @@ -224,12 +259,12 @@ public: * @param[in] Current progress * @return The progress after the alpha function has been aplied */ - float ApplyAlphaFunction( float progress ) const + float ApplyAlphaFunction(float progress) const { float result = progress; - AlphaFunction::Mode alphaFunctionMode( mAlphaFunction.GetMode() ); - if( alphaFunctionMode == AlphaFunction::BUILTIN_FUNCTION ) + AlphaFunction::Mode alphaFunctionMode(mAlphaFunction.GetMode()); + if(alphaFunctionMode == AlphaFunction::BUILTIN_FUNCTION) { switch(mAlphaFunction.GetBuiltinFunction()) { @@ -240,7 +275,7 @@ public: } case AlphaFunction::REVERSE: { - result = 1.0f-progress; + result = 1.0f - progress; break; } case AlphaFunction::EASE_IN_SQUARE: @@ -250,7 +285,7 @@ public: } case AlphaFunction::EASE_OUT_SQUARE: { - result = 1.0f - (1.0f-progress) * (1.0f-progress); + result = 1.0f - (1.0f - progress) * (1.0f - progress); break; } case AlphaFunction::EASE_IN: @@ -260,12 +295,12 @@ public: } case AlphaFunction::EASE_OUT: { - result = (progress-1.0f) * (progress-1.0f) * (progress-1.0f) + 1.0f; + result = (progress - 1.0f) * (progress - 1.0f) * (progress - 1.0f) + 1.0f; break; } case AlphaFunction::EASE_IN_OUT: { - result = progress*progress*(3.0f-2.0f*progress); + result = progress * progress * (3.0f - 2.0f * progress); break; } case AlphaFunction::EASE_IN_SINE: @@ -297,7 +332,7 @@ public: { const float sqrt2 = 1.70158f; progress -= 1.0f; - result = 1.0f + progress * progress * ( ( sqrt2 + 1.0f ) * progress + sqrt2 ); + result = 1.0f + progress * progress * ((sqrt2 + 1.0f) * progress + sqrt2); break; } case AlphaFunction::COUNT: @@ -306,10 +341,10 @@ public: } } } - else if( alphaFunctionMode == AlphaFunction::CUSTOM_FUNCTION ) + else if(alphaFunctionMode == AlphaFunction::CUSTOM_FUNCTION) { AlphaFunctionPrototype customFunction = mAlphaFunction.GetCustomFunction(); - if( customFunction ) + if(customFunction) { result = customFunction(progress); } @@ -318,20 +353,20 @@ public: { //If progress is very close to 0 or very close to 1 we don't need to evaluate the curve as the result will //be almost 0 or almost 1 respectively - if( ( progress > Math::MACHINE_EPSILON_1 ) && ((1.0f - progress) > Math::MACHINE_EPSILON_1) ) + if((progress > Math::MACHINE_EPSILON_1) && ((1.0f - progress) > Math::MACHINE_EPSILON_1)) { Dali::Vector4 controlPoints = mAlphaFunction.GetBezierControlPoints(); - static const float tolerance = 0.001f; //10 iteration max + static const float tolerance = 0.001f; //10 iteration max //Perform a binary search on the curve float lowerBound(0.0f); float upperBound(1.0f); float currentT(0.5f); - float currentX = EvaluateCubicBezier( controlPoints.x, controlPoints.z, currentT); - while( fabs( progress - currentX ) > tolerance ) + float currentX = EvaluateCubicBezier(controlPoints.x, controlPoints.z, currentT); + while(fabsf(progress - currentX) > tolerance) { - if( progress > currentX ) + if(progress > currentX) { lowerBound = currentT; } @@ -339,10 +374,10 @@ public: { upperBound = currentT; } - currentT = (upperBound+lowerBound)*0.5f; - currentX = EvaluateCubicBezier( controlPoints.x, controlPoints.z, currentT); + currentT = (upperBound + lowerBound) * 0.5f; + currentX = EvaluateCubicBezier(controlPoints.x, controlPoints.z, currentT); } - result = EvaluateCubicBezier( controlPoints.y, controlPoints.w, currentT); + result = EvaluateCubicBezier(controlPoints.y, controlPoints.w, currentT); } } @@ -354,7 +389,7 @@ public: * Property is only baked if the animator is active. * @param [in] action The disconnect action. */ - void SetDisconnectAction( Dali::Animation::EndAction action ) + void SetDisconnectAction(Dali::Animation::EndAction action) { mDisconnectAction = action; } @@ -374,22 +409,13 @@ public: * @post When the animator becomes active, it applies the disconnect-action if the property owner is then disconnected. * @note When the property owner is disconnected, the active state is set to false. */ - void SetActive( bool active ) - { - mActive = active; - } - - /** - * Retrieve whether the animator has been set to active or not. - * @return The active state. - */ - bool GetActive() const + void SetActive(bool active) { - return mActive; + mAnimationPlaying = active; } /** - * 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 @@ -401,7 +427,7 @@ public: * @brief Sets the looping mode. * @param[in] loopingMode True when the looping mode is AUTO_REVERSE */ - void SetLoopingMode( bool loopingMode ) + void SetLoopingMode(bool loopingMode) { mAutoReverseEnabled = loopingMode; } @@ -412,7 +438,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. @@ -420,10 +449,36 @@ 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); + } -protected: + if(mPropertyOwner) + { + mPropertyOwner->SetUpdated(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: /** * Helper function to evaluate a cubic bezier curve assuming first point is at 0.0 and last point is at 1.0 * @param[in] p0 First control point of the bezier curve @@ -431,36 +486,41 @@ protected: * @param[in] t A floating point value between 0.0 and 1.0 * @return Value of the curve at progress t */ - inline float EvaluateCubicBezier( float p0, float p1, float t ) const + inline float EvaluateCubicBezier(float p0, float p1, float t) const { - float tSquare = t*t; - return 3.0f*(1.0f-t)*(1.0f-t)*t*p0 + 3.0f*(1.0f-t)*tSquare*p1 + tSquare*t; + float tSquare = t * t; + return 3.0f * (1.0f - t) * (1.0f - t) * t * p0 + 3.0f * (1.0f - t) * tSquare * p1 + tSquare * t; } LifecycleObserver* mLifecycleObserver; + PropertyOwner* mPropertyOwner; + float mDurationSeconds; float mIntervalDelaySeconds; float mSpeedFactor; - - int mLoopCount; + float mCurrentProgress; AlphaFunction mAlphaFunction; - Dali::Animation::EndAction mDisconnectAction; ///< EndAction to apply when target object gets disconnected from the stage. - bool mActive:1; ///< Animator is "active" while it's running. - bool mEnabled:1; ///< Animator is "enabled" while its target object is valid and on the stage. - bool mConnectedToSceneGraph:1; ///< True if ConnectToSceneGraph() has been called in update-thread. - bool mAutoReverseEnabled:1; + int32_t mLoopCount{1}; + Dali::Animation::EndAction mDisconnectAction; ///< EndAction to apply when target object gets disconnected from the stage. + bool mAnimationPlaying : 1; ///< whether disconnect has been applied while it's running. + bool mEnabled : 1; ///< Animator is "enabled" while its target object is valid and on the stage. + bool mConnectedToSceneGraph : 1; ///< True if ConnectToSceneGraph() has been called in update-thread. + bool mAutoReverseEnabled : 1; }; /** * An animator for a specific property type PropertyType. */ -template < typename PropertyType, typename PropertyAccessorType > -class Animator : public AnimatorBase, public PropertyOwner::Observer +template +class Animator final : public AnimatorBase { -public: + using AnimatorFunction = std::function; + + AnimatorFunction mAnimatorFunction; +public: /** * Construct a new property animator. * @param[in] property The animatable property; only valid while the Animator is attached. @@ -469,158 +529,78 @@ public: * @param[in] timePeriod The time period of this animation. * @return A newly allocated animator. */ - static AnimatorBase* New( const PropertyOwner& propertyOwner, - const PropertyBase& property, - AnimatorFunctionBase* animatorFunction, - AlphaFunction alphaFunction, - const TimePeriod& timePeriod ) + static AnimatorBase* New(const PropertyOwner& propertyOwner, + const PropertyBase& property, + AnimatorFunction animatorFunction, + 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; - } - - /** - * Virtual destructor. - */ - 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 ( mActive && mDisconnectAction != Dali::Animation::Discard ) - { - // Bake to target-value if BakeFinal, otherwise bake current value - Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true ); - } - - mActive = false; - mEnabled = false; + return new Animator(const_cast(&propertyOwner), + const_cast(&property), + std::move(animatorFunction), + alphaFunction, + timePeriod); } /** - * Called shortly before mPropertyOwner is destroyed + * @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) */ - virtual void PropertyOwnerDestroyed( PropertyOwner& owner ) + void DoUpdate(BufferIndex bufferIndex, bool bake, float alpha) final { - mPropertyOwner = NULL; - } + const PropertyType& current = mPropertyAccessor.Get(bufferIndex); - /** - * From AnimatorBase. - */ - virtual void Update( BufferIndex bufferIndex, float progress, bool bake ) - { - if( mLoopCount >= 0 ) - { - // Update the progress value - progress = SetProgress( progress ); - } - - float alpha = ApplyAlphaFunction( progress ); + // need to cast the return value in case property is integer + const PropertyType result = static_cast(mAnimatorFunction(alpha, current)); - const PropertyType& current = mPropertyAccessor.Get( bufferIndex ); - - const PropertyType result = (*mAnimatorFunction)( alpha, current ); - if ( bake ) + if(bake) { - mPropertyAccessor.Bake( bufferIndex, result ); + mPropertyAccessor.Bake(bufferIndex, result); } else { - mPropertyAccessor.Set( bufferIndex, result ); + mPropertyAccessor.Set(bufferIndex, result); } - - mCurrentProgress = progress; - } - - /** - * From AnimatorBase. - */ - virtual bool Orphan() - { - return (mPropertyOwner == NULL); } private: - /** * Private constructor; see also Animator::New(). */ - Animator( PropertyOwner* propertyOwner, - PropertyBase* property, - AnimatorFunctionBase* animatorFunction ) - : mPropertyOwner( propertyOwner ), - mPropertyAccessor( property ), - mAnimatorFunction( animatorFunction ), - mCurrentProgress( 0.0f ) + Animator(PropertyOwner* propertyOwner, + PropertyBase* property, + AnimatorFunction animatorFunction, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod) + : AnimatorBase(propertyOwner, alphaFunction, timePeriod), + mAnimatorFunction(std::move(animatorFunction)), + mPropertyAccessor(property) { // WARNING - this object is created in the event-thread // The scene-graph mPropertyOwner object cannot be observed here } // Undefined - Animator( const Animator& ); + Animator(const Animator&); // Undefined - Animator& operator=( const Animator& ); + Animator& operator=(const Animator&); protected: - - PropertyOwner* mPropertyOwner; PropertyAccessorType mPropertyAccessor; - - AnimatorFunctionBase* mAnimatorFunction; - float mCurrentProgress; }; - - /** * An animator for a specific property type PropertyType. */ -template -class AnimatorTransformProperty : public AnimatorBase, public PropertyOwner::Observer +template +class AnimatorTransformProperty final : public AnimatorBase { -public: + using AnimatorFunction = std::function; + AnimatorFunction mAnimatorFunction; + +public: /** * Construct a new property animator. * @param[in] property The animatable property; only valid while the Animator is attached. @@ -629,251 +609,109 @@ public: * @param[in] timePeriod The time period of this animation. * @return A newly allocated animator. */ - static AnimatorBase* New( const PropertyOwner& propertyOwner, - const PropertyBase& property, - AnimatorFunctionBase* animatorFunction, - AlphaFunction alphaFunction, - const TimePeriod& timePeriod ) + static AnimatorBase* New(const PropertyOwner& propertyOwner, + const PropertyBase& property, + AnimatorFunction animatorFunction, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod) { - // 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; - } - - /** - * Virtual destructor. - */ - 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 ( mActive && mDisconnectAction != Dali::Animation::Discard ) - { - // Bake to target-value if BakeFinal, otherwise bake current value - Update( bufferIndex, ( mDisconnectAction == Dali::Animation::Bake ? mCurrentProgress : 1.0f ), true ); - } - - mActive = false; - mEnabled = false; + return new AnimatorTransformProperty(const_cast(&propertyOwner), + const_cast(&property), + std::move(animatorFunction), + alphaFunction, + timePeriod); } /** - * Called shortly before mPropertyOwner is destroyed + * @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) */ - virtual void PropertyOwnerDestroyed( PropertyOwner& owner ) + void DoUpdate(BufferIndex bufferIndex, bool bake, float alpha) final { - mPropertyOwner = NULL; - } - - /** - * From AnimatorBase. - */ - virtual void Update( BufferIndex bufferIndex, float progress, bool bake ) - { - if( mLoopCount >= 0 ) - { - // Update the progress value - progress = SetProgress( progress ); - } + const PropertyType& current = mPropertyAccessor.Get(bufferIndex); - float alpha = ApplyAlphaFunction( progress ); + // need to cast the return value in case property is integer + const PropertyType result = static_cast(mAnimatorFunction(alpha, current)); - const T& current = mPropertyAccessor.Get( bufferIndex ); - - const T result = (*mAnimatorFunction)( alpha, current ); - - - if ( bake ) + if(bake) { - mPropertyAccessor.Bake( bufferIndex, result ); + mPropertyAccessor.Bake(bufferIndex, result); } else { - mPropertyAccessor.Set( bufferIndex, result ); + mPropertyAccessor.Set(bufferIndex, result); } - - mCurrentProgress = progress; - } - - /** - * From AnimatorBase. - */ - virtual bool Orphan() - { - return (mPropertyOwner == NULL); } private: - /** * Private constructor; see also Animator::New(). */ - AnimatorTransformProperty( PropertyOwner* propertyOwner, - PropertyBase* property, - AnimatorFunctionBase* animatorFunction ) - : mPropertyOwner( propertyOwner ), - mPropertyAccessor( property ), - mAnimatorFunction( animatorFunction ), - mCurrentProgress( 0.0f ) + AnimatorTransformProperty(PropertyOwner* propertyOwner, + PropertyBase* property, + AnimatorFunction animatorFunction, + AlphaFunction alphaFunction, + const TimePeriod& timePeriod) + : AnimatorBase(propertyOwner, alphaFunction, timePeriod), + mAnimatorFunction(std::move(animatorFunction)), + 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 int& property) - { - return property; - } - - virtual float operator()(float progress, const unsigned int& property) - { - return 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 +struct AnimateByInteger { AnimateByInteger(const int& relativeValue) : mRelative(relativeValue) { } - using AnimatorFunctionBase::operator(); - float operator()(float alpha, const int& property) + float operator()(float alpha, const int32_t& property) { - return int(property + mRelative * alpha + 0.5f ); + // integers need to be correctly rounded + return roundf(static_cast(property) + static_cast(mRelative) * alpha); } - int mRelative; + int32_t mRelative; }; -struct AnimateToInteger : public AnimatorFunctionBase +struct AnimateToInteger { AnimateToInteger(const int& targetValue) : mTarget(targetValue) { } - using AnimatorFunctionBase::operator(); - float operator()(float alpha, const int& property) + float operator()(float alpha, const int32_t& property) { - return int(property + ((mTarget - property) * alpha) + 0.5f); + // integers need to be correctly rounded + return roundf(static_cast(property) + (static_cast(mTarget - property) * alpha)); } - int mTarget; + int32_t mTarget; }; -struct AnimateByFloat : public AnimatorFunctionBase +struct AnimateByFloat { AnimateByFloat(const float& relativeValue) : mRelative(relativeValue) { } - using AnimatorFunctionBase::operator(); float operator()(float alpha, const float& property) { return float(property + mRelative * alpha); @@ -882,14 +720,13 @@ struct AnimateByFloat : public AnimatorFunctionBase float mRelative; }; -struct AnimateToFloat : public AnimatorFunctionBase +struct AnimateToFloat { AnimateToFloat(const float& targetValue) : mTarget(targetValue) { } - using AnimatorFunctionBase::operator(); float operator()(float alpha, const float& property) { return float(property + ((mTarget - property) * alpha)); @@ -898,14 +735,13 @@ struct AnimateToFloat : public AnimatorFunctionBase float mTarget; }; -struct AnimateByVector2 : public AnimatorFunctionBase +struct AnimateByVector2 { AnimateByVector2(const Vector2& relativeValue) : mRelative(relativeValue) { } - using AnimatorFunctionBase::operator(); Vector2 operator()(float alpha, const Vector2& property) { return Vector2(property + mRelative * alpha); @@ -914,14 +750,13 @@ struct AnimateByVector2 : public AnimatorFunctionBase Vector2 mRelative; }; -struct AnimateToVector2 : public AnimatorFunctionBase +struct AnimateToVector2 { AnimateToVector2(const Vector2& targetValue) : mTarget(targetValue) { } - using AnimatorFunctionBase::operator(); Vector2 operator()(float alpha, const Vector2& property) { return Vector2(property + ((mTarget - property) * alpha)); @@ -930,14 +765,13 @@ struct AnimateToVector2 : public AnimatorFunctionBase Vector2 mTarget; }; -struct AnimateByVector3 : public AnimatorFunctionBase +struct AnimateByVector3 { AnimateByVector3(const Vector3& relativeValue) : mRelative(relativeValue) { } - using AnimatorFunctionBase::operator(); Vector3 operator()(float alpha, const Vector3& property) { return Vector3(property + mRelative * alpha); @@ -946,14 +780,13 @@ struct AnimateByVector3 : public AnimatorFunctionBase Vector3 mRelative; }; -struct AnimateToVector3 : public AnimatorFunctionBase +struct AnimateToVector3 { AnimateToVector3(const Vector3& targetValue) : mTarget(targetValue) { } - using AnimatorFunctionBase::operator(); Vector3 operator()(float alpha, const Vector3& property) { return Vector3(property + ((mTarget - property) * alpha)); @@ -962,14 +795,13 @@ struct AnimateToVector3 : public AnimatorFunctionBase Vector3 mTarget; }; -struct AnimateByVector4 : public AnimatorFunctionBase +struct AnimateByVector4 { AnimateByVector4(const Vector4& relativeValue) : mRelative(relativeValue) { } - using AnimatorFunctionBase::operator(); Vector4 operator()(float alpha, const Vector4& property) { return Vector4(property + mRelative * alpha); @@ -978,14 +810,13 @@ struct AnimateByVector4 : public AnimatorFunctionBase Vector4 mRelative; }; -struct AnimateToVector4 : public AnimatorFunctionBase +struct AnimateToVector4 { AnimateToVector4(const Vector4& targetValue) : mTarget(targetValue) { } - using AnimatorFunctionBase::operator(); Vector4 operator()(float alpha, const Vector4& property) { return Vector4(property + ((mTarget - property) * alpha)); @@ -994,14 +825,13 @@ struct AnimateToVector4 : public AnimatorFunctionBase Vector4 mTarget; }; -struct AnimateByOpacity : public AnimatorFunctionBase +struct AnimateByOpacity { AnimateByOpacity(const float& relativeValue) : mRelative(relativeValue) { } - using AnimatorFunctionBase::operator(); Vector4 operator()(float alpha, const Vector4& property) { Vector4 result(property); @@ -1013,14 +843,13 @@ struct AnimateByOpacity : public AnimatorFunctionBase float mRelative; }; -struct AnimateToOpacity : public AnimatorFunctionBase +struct AnimateToOpacity { AnimateToOpacity(const float& targetValue) : mTarget(targetValue) { } - using AnimatorFunctionBase::operator(); Vector4 operator()(float alpha, const Vector4& property) { Vector4 result(property); @@ -1032,14 +861,13 @@ struct AnimateToOpacity : public AnimatorFunctionBase float mTarget; }; -struct AnimateByBoolean : public AnimatorFunctionBase +struct AnimateByBoolean { AnimateByBoolean(bool relativeValue) : mRelative(relativeValue) { } - using AnimatorFunctionBase::operator(); bool operator()(float alpha, const bool& property) { // Alpha is not useful here, just keeping to the same template as other update functors @@ -1049,14 +877,13 @@ struct AnimateByBoolean : public AnimatorFunctionBase bool mRelative; }; -struct AnimateToBoolean : public AnimatorFunctionBase +struct AnimateToBoolean { AnimateToBoolean(bool targetValue) : mTarget(targetValue) { } - using AnimatorFunctionBase::operator(); bool operator()(float alpha, const bool& property) { // Alpha is not useful here, just keeping to the same template as other update functors @@ -1066,18 +893,17 @@ struct AnimateToBoolean : public AnimatorFunctionBase bool mTarget; }; -struct RotateByAngleAxis : public AnimatorFunctionBase +struct RotateByAngleAxis { RotateByAngleAxis(const Radian& angleRadians, const Vector3& axis) - : mAngleRadians( angleRadians ), + : mAngleRadians(angleRadians), mAxis(axis.x, axis.y, axis.z) { } - using AnimatorFunctionBase::operator(); Quaternion operator()(float alpha, const Quaternion& rotation) { - if (alpha > 0.0f) + if(alpha > 0.0f) { return rotation * Quaternion(mAngleRadians * alpha, mAxis); } @@ -1085,18 +911,17 @@ struct RotateByAngleAxis : public AnimatorFunctionBase return rotation; } - Radian mAngleRadians; + Radian mAngleRadians; Vector3 mAxis; }; -struct RotateToQuaternion : public AnimatorFunctionBase +struct RotateToQuaternion { RotateToQuaternion(const Quaternion& targetValue) : mTarget(targetValue) { } - using AnimatorFunctionBase::operator(); Quaternion operator()(float alpha, const Quaternion& rotation) { return Quaternion::Slerp(rotation, mTarget, alpha); @@ -1105,187 +930,181 @@ struct RotateToQuaternion : public AnimatorFunctionBase Quaternion mTarget; }; - -struct KeyFrameBooleanFunctor : public AnimatorFunctionBase +struct KeyFrameBooleanFunctor { - KeyFrameBooleanFunctor(KeyFrameBooleanPtr keyFrames) - : mKeyFrames(keyFrames) + KeyFrameBooleanFunctor(KeyFrameBoolean keyFrames) + : mKeyFrames(std::move(keyFrames)) { } - using AnimatorFunctionBase::operator(); bool operator()(float progress, const bool& property) { - if(mKeyFrames->IsActive(progress)) + if(mKeyFrames.IsActive(progress)) { - return mKeyFrames->GetValue(progress, Dali::Animation::Linear); + return mKeyFrames.GetValue(progress, Dali::Animation::LINEAR); } return property; } - KeyFrameBooleanPtr mKeyFrames; + KeyFrameBoolean mKeyFrames; }; -struct KeyFrameIntegerFunctor : public AnimatorFunctionBase +struct KeyFrameIntegerFunctor { - KeyFrameIntegerFunctor(KeyFrameIntegerPtr keyFrames, Interpolation interpolation) - : mKeyFrames(keyFrames),mInterpolation(interpolation) + KeyFrameIntegerFunctor(KeyFrameInteger keyFrames, Interpolation interpolation) + : mKeyFrames(std::move(keyFrames)), + mInterpolation(interpolation) { } - using AnimatorFunctionBase::operator(); - float operator()(float progress, const int& property) + float operator()(float progress, const int32_t& property) { - if(mKeyFrames->IsActive(progress)) + if(mKeyFrames.IsActive(progress)) { - return mKeyFrames->GetValue(progress, mInterpolation); + return static_cast(mKeyFrames.GetValue(progress, mInterpolation)); } - return property; + return static_cast(property); } - KeyFrameIntegerPtr mKeyFrames; - Interpolation mInterpolation; + KeyFrameInteger mKeyFrames; + Interpolation mInterpolation; }; -struct KeyFrameNumberFunctor : public AnimatorFunctionBase +struct KeyFrameNumberFunctor { - KeyFrameNumberFunctor(KeyFrameNumberPtr keyFrames, Interpolation interpolation) - : mKeyFrames(keyFrames),mInterpolation(interpolation) + KeyFrameNumberFunctor(KeyFrameNumber keyFrames, Interpolation interpolation) + : mKeyFrames(std::move(keyFrames)), + mInterpolation(interpolation) { } - using AnimatorFunctionBase::operator(); float operator()(float progress, const float& property) { - if(mKeyFrames->IsActive(progress)) + if(mKeyFrames.IsActive(progress)) { - return mKeyFrames->GetValue(progress, mInterpolation); + return mKeyFrames.GetValue(progress, mInterpolation); } return property; } - KeyFrameNumberPtr mKeyFrames; - Interpolation mInterpolation; + KeyFrameNumber mKeyFrames; + Interpolation mInterpolation; }; -struct KeyFrameVector2Functor : public AnimatorFunctionBase +struct KeyFrameVector2Functor { - KeyFrameVector2Functor(KeyFrameVector2Ptr keyFrames, Interpolation interpolation) - : mKeyFrames(keyFrames),mInterpolation(interpolation) + KeyFrameVector2Functor(KeyFrameVector2 keyFrames, Interpolation interpolation) + : mKeyFrames(std::move(keyFrames)), + mInterpolation(interpolation) { } - using AnimatorFunctionBase::operator(); Vector2 operator()(float progress, const Vector2& property) { - if(mKeyFrames->IsActive(progress)) + if(mKeyFrames.IsActive(progress)) { - return mKeyFrames->GetValue(progress, mInterpolation); + return mKeyFrames.GetValue(progress, mInterpolation); } return property; } - KeyFrameVector2Ptr mKeyFrames; - Interpolation mInterpolation; + KeyFrameVector2 mKeyFrames; + Interpolation mInterpolation; }; - -struct KeyFrameVector3Functor : public AnimatorFunctionBase +struct KeyFrameVector3Functor { - KeyFrameVector3Functor(KeyFrameVector3Ptr keyFrames, Interpolation interpolation) - : mKeyFrames(keyFrames),mInterpolation(interpolation) + KeyFrameVector3Functor(KeyFrameVector3 keyFrames, Interpolation interpolation) + : mKeyFrames(std::move(keyFrames)), + mInterpolation(interpolation) { } - using AnimatorFunctionBase::operator(); Vector3 operator()(float progress, const Vector3& property) { - if(mKeyFrames->IsActive(progress)) + if(mKeyFrames.IsActive(progress)) { - return mKeyFrames->GetValue(progress, mInterpolation); + return mKeyFrames.GetValue(progress, mInterpolation); } return property; } - KeyFrameVector3Ptr mKeyFrames; - Interpolation mInterpolation; + KeyFrameVector3 mKeyFrames; + Interpolation mInterpolation; }; -struct KeyFrameVector4Functor : public AnimatorFunctionBase +struct KeyFrameVector4Functor { - KeyFrameVector4Functor(KeyFrameVector4Ptr keyFrames, Interpolation interpolation) - : mKeyFrames(keyFrames),mInterpolation(interpolation) + KeyFrameVector4Functor(KeyFrameVector4 keyFrames, Interpolation interpolation) + : mKeyFrames(std::move(keyFrames)), + mInterpolation(interpolation) { } - using AnimatorFunctionBase::operator(); Vector4 operator()(float progress, const Vector4& property) { - if(mKeyFrames->IsActive(progress)) + if(mKeyFrames.IsActive(progress)) { - return mKeyFrames->GetValue(progress, mInterpolation); + return mKeyFrames.GetValue(progress, mInterpolation); } return property; } - KeyFrameVector4Ptr mKeyFrames; - Interpolation mInterpolation; + KeyFrameVector4 mKeyFrames; + Interpolation mInterpolation; }; -struct KeyFrameQuaternionFunctor : public AnimatorFunctionBase +struct KeyFrameQuaternionFunctor { - KeyFrameQuaternionFunctor(KeyFrameQuaternionPtr keyFrames) - : mKeyFrames(keyFrames) + KeyFrameQuaternionFunctor(KeyFrameQuaternion keyFrames) + : mKeyFrames(std::move(keyFrames)) { } - using AnimatorFunctionBase::operator(); Quaternion operator()(float progress, const Quaternion& property) { - if(mKeyFrames->IsActive(progress)) + if(mKeyFrames.IsActive(progress)) { - return mKeyFrames->GetValue(progress, Dali::Animation::Linear); + return mKeyFrames.GetValue(progress, Dali::Animation::LINEAR); } return property; } - KeyFrameQuaternionPtr mKeyFrames; + KeyFrameQuaternion mKeyFrames; }; -struct PathPositionFunctor : public AnimatorFunctionBase +struct PathPositionFunctor { - PathPositionFunctor( PathPtr path ) + PathPositionFunctor(PathPtr path) : mPath(path) { } - using AnimatorFunctionBase::operator(); Vector3 operator()(float progress, const Vector3& property) { Vector3 position(property); - static_cast( mPath->SamplePosition(progress, position) ); + static_cast(mPath->SamplePosition(progress, position)); return position; } PathPtr mPath; }; -struct PathRotationFunctor : public AnimatorFunctionBase +struct PathRotationFunctor { - PathRotationFunctor( PathPtr path, const Vector3& forward ) + PathRotationFunctor(PathPtr path, const Vector3& forward) : mPath(path), - mForward( forward ) + mForward(forward) { mForward.Normalize(); } - using AnimatorFunctionBase::operator(); Quaternion operator()(float progress, const Quaternion& property) { Vector3 tangent; - if( mPath->SampleTangent(progress, tangent) ) + if(mPath->SampleTangent(progress, tangent)) { - return Quaternion( mForward, tangent ); + return Quaternion(mForward, tangent); } else { @@ -1301,4 +1120,4 @@ struct PathRotationFunctor : public AnimatorFunctionBase } // namespace Dali -#endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__ +#endif // DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H