-#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) 2014 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.
*
*/
+// EXTERNAL INCLUDES
+#include <cmath>
+#include <functional>
+
// INTERNAL INCLUDES
-#include <dali/internal/common/owner-container.h>
#include <dali/internal/event/animation/key-frames-impl.h>
#include <dali/internal/event/animation/path-impl.h>
-#include <dali/internal/update/nodes/node.h>
+#include <dali/internal/update/animation/property-accessor.h>
#include <dali/internal/update/common/property-base.h>
+#include <dali/internal/update/common/property-owner.h>
#include <dali/public-api/animation/alpha-function.h>
#include <dali/public-api/animation/animation.h>
#include <dali/public-api/animation/time-period.h>
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:
+ using AlphaFunc = float (*)(float progress); ///< Definition of an alpha function
- typedef float (*AlphaFunc)(float progress); ///< Definition of an alpha function
+ /**
+ * Observer to determine when the animator is no longer present
+ */
+ class LifecycleObserver
+ {
+ public:
+ /**
+ * Called shortly before the animator is destroyed.
+ */
+ virtual void ObjectDestroyed() = 0;
+
+ protected:
+ /**
+ * Virtual destructor, no deletion through this interface
+ */
+ virtual ~LifecycleObserver() = default;
+ };
/**
* Constructor.
*/
- AnimatorBase()
- : mDurationSeconds(1.0f),
- mInitialDelaySeconds(0.0f),
- mAlphaFunction(AlphaFunction::DEFAULT),
- mDisconnectAction(Dali::Animation::BakeFinal),
- mActive(false),
- mEnabled(true)
+ AnimatorBase(PropertyOwner* propertyOwner,
+ AlphaFunction alphaFunction,
+ const TimePeriod& timePeriod)
+ : mLifecycleObserver(nullptr),
+ mPropertyOwner(propertyOwner),
+ mDurationSeconds(timePeriod.durationSeconds),
+ mIntervalDelaySeconds(timePeriod.delaySeconds),
+ mSpeedFactor(1.0f),
+ mCurrentProgress(0.f),
+ mAlphaFunction(alphaFunction),
+ mDisconnectAction(Dali::Animation::BAKE_FINAL),
+ mAnimationPlaying(false),
+ mEnabled(true),
+ mConnectedToSceneGraph(false),
+ mAutoReverseEnabled(false)
{
}
/**
* Virtual destructor.
*/
- virtual ~AnimatorBase()
+ ~AnimatorBase() override
{
+ if(mPropertyOwner && mConnectedToSceneGraph)
+ {
+ mPropertyOwner->RemoveObserver(*this);
+ }
+ if(mLifecycleObserver != nullptr)
+ {
+ mLifecycleObserver->ObjectDestroyed();
+ }
+ }
+
+ void AddLifecycleObserver(LifecycleObserver& observer)
+ {
+ mLifecycleObserver = &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.
+ */
+ void ConnectToSceneGraph()
+ {
+ mConnectedToSceneGraph = true;
+ mPropertyOwner->AddObserver(*this);
+
+ // Enable if the target object is valid and connected to the scene graph.
+ mEnabled = mPropertyOwner->IsAnimationPossible();
}
/**
* Retrieve the duration of the animator.
* @return The duration in seconds.
*/
- float GetDuration()
+ float GetDuration() const
{
return mDurationSeconds;
}
+ void SetSpeedFactor(float factor)
+ {
+ mSpeedFactor = factor;
+ }
+
+ void SetLoopCount(int32_t loopCount)
+ {
+ mLoopCount = loopCount;
+ }
+
+ float SetProgress(float progress)
+ {
+ float value = 0.0f;
+
+ if(mAutoReverseEnabled)
+ {
+ if(mSpeedFactor > 0.0f)
+ {
+ value = 1.0f - 2.0f * std::abs(progress - 0.5f);
+ }
+ // Reverse mode
+ else if(mSpeedFactor < 0.0f)
+ {
+ value = 2.0f * std::abs(progress - 0.5f);
+ }
+ }
+ else
+ {
+ value = progress;
+ }
+
+ return value;
+ }
+
/**
* Set the delay before the animator should take effect.
* The default is zero i.e. no delay.
* @param [in] seconds The delay in seconds.
*/
- void SetInitialDelay(float seconds)
+ void SetIntervalDelay(float seconds)
{
- mInitialDelaySeconds = seconds;
+ mIntervalDelaySeconds = seconds;
}
/**
- * Retrieve the initial delay of the animator.
+ * Retrieve the delay before the animator should take effect.
* @return The delay in seconds.
*/
- float GetInitialDelay()
+ float GetIntervalDelay() const
{
- return mInitialDelaySeconds;
+ return mIntervalDelaySeconds;
}
/**
return mAlphaFunction;
}
- /*
+ /**
* Applies the alpha function to the specified progress
* @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())
{
}
case AlphaFunction::REVERSE:
{
- result = 1.0f-progress;
+ result = 1.0f - progress;
break;
}
case AlphaFunction::EASE_IN_SQUARE:
}
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:
}
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:
{
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:
}
}
}
- else if( alphaFunctionMode == AlphaFunction::CUSTOM_FUNCTION )
+ else if(alphaFunctionMode == AlphaFunction::CUSTOM_FUNCTION)
{
AlphaFunctionPrototype customFunction = mAlphaFunction.GetCustomFunction();
- if( customFunction )
+ if(customFunction)
{
result = customFunction(progress);
}
{
//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;
}
{
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);
}
}
* 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;
}
* @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 )
+ void SetActive(bool active)
{
- mActive = active;
+ mAnimationPlaying = active;
}
/**
- * Retrieve whether the animator has been set to active or not.
- * @return The active state.
+ * Whether the animator's target object is valid and on the stage.
+ * @return The enabled state.
*/
- bool GetActive() const
+ bool IsEnabled() const
{
- return mActive;
+ return mEnabled;
}
- /*
- * Retrive wheter the animator's target object is valid and on the stage.
- * @return The enabled state.
+ /**
+ * @brief Sets the looping mode.
+ * @param[in] loopingMode True when the looping mode is AUTO_REVERSE
*/
- bool IsEnabled() const
+ void SetLoopingMode(bool loopingMode)
{
- return mEnabled;
+ mAutoReverseEnabled = loopingMode;
}
+
/**
* Returns wheter the target object of the animator is still valid
* or has been destroyed.
* @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.
* @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
* @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 mInitialDelaySeconds;
+ float mIntervalDelaySeconds;
+ float mSpeedFactor;
+ 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.
+ 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<typename PropertyType, typename PropertyAccessorType>
+class Animator final : public AnimatorBase
{
-public:
+ using AnimatorFunction = std::function<PropertyType(float, const PropertyType&)>;
+ AnimatorFunction mAnimatorFunction;
+
+public:
/**
* Construct a new property animator.
* @param[in] property The animatable property; only valid while the Animator is attached.
* @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*>( &propertyOwner ),
- const_cast<PropertyBase*>( &property ),
- animatorFunction );
-
- animator->SetAlphaFunction( alphaFunction );
- animator->SetInitialDelay( timePeriod.delaySeconds );
- animator->SetDuration( timePeriod.durationSeconds );
-
- return animator;
+ return new Animator(const_cast<PropertyOwner*>(&propertyOwner),
+ const_cast<PropertyBase*>(&property),
+ std::move(animatorFunction),
+ alphaFunction,
+ timePeriod);
}
/**
- * Virtual destructor.
+ * @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha )
*/
- virtual ~Animator()
+ void DoUpdate(BufferIndex bufferIndex, bool bake, float alpha) final
{
- if (mPropertyOwner)
+ const PropertyType& current = mPropertyAccessor.Get(bufferIndex);
+
+ // need to cast the return value in case property is integer
+ const PropertyType result = static_cast<PropertyType>(mAnimatorFunction(alpha, current));
+
+ if(bake)
{
- mPropertyOwner->RemoveObserver(*this);
+ mPropertyAccessor.Bake(bufferIndex, result);
}
-
- if( mAnimatorFunction )
+ else
{
- delete mAnimatorFunction;
+ mPropertyAccessor.Set(bufferIndex, result);
}
}
+private:
/**
- * Called when mPropertyOwner is connected to the scene graph.
+ * Private constructor; see also Animator::New().
*/
- virtual void PropertyOwnerConnected( PropertyOwner& owner )
+ Animator(PropertyOwner* propertyOwner,
+ PropertyBase* property,
+ AnimatorFunction animatorFunction,
+ AlphaFunction alphaFunction,
+ const TimePeriod& timePeriod)
+ : AnimatorBase(propertyOwner, alphaFunction, timePeriod),
+ mAnimatorFunction(std::move(animatorFunction)),
+ mPropertyAccessor(property)
{
- mEnabled = true;
+ // WARNING - this object is created in the event-thread
+ // The scene-graph mPropertyOwner object cannot be observed here
}
- /**
- * 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 );
- }
+ // Undefined
+ Animator(const Animator&);
- mActive = false;
- mEnabled = false;
- }
+ // Undefined
+ Animator& operator=(const Animator&);
+
+protected:
+ PropertyAccessorType mPropertyAccessor;
+};
+/**
+ * An animator for a specific property type PropertyType.
+ */
+template<typename PropertyType, typename PropertyAccessorType>
+class AnimatorTransformProperty final : public AnimatorBase
+{
+ using AnimatorFunction = std::function<PropertyType(float, const PropertyType&)>;
+
+ AnimatorFunction mAnimatorFunction;
+
+public:
/**
- * Called shortly before mPropertyOwner is destroyed
+ * Construct a new property animator.
+ * @param[in] property The animatable property; only valid while the Animator is attached.
+ * @param[in] animatorFunction The function used to animate the property.
+ * @param[in] alphaFunction The alpha function to apply.
+ * @param[in] timePeriod The time period of this animation.
+ * @return A newly allocated animator.
*/
- virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
+ static AnimatorBase* New(const PropertyOwner& propertyOwner,
+ const PropertyBase& property,
+ AnimatorFunction animatorFunction,
+ AlphaFunction alphaFunction,
+ const TimePeriod& timePeriod)
{
- mPropertyOwner = NULL;
- mPropertyAccessor.Reset();
- mEnabled = false;
+ // The property was const in the actor-thread, but animators are used in the scene-graph thread.
+ return new AnimatorTransformProperty(const_cast<PropertyOwner*>(&propertyOwner),
+ const_cast<PropertyBase*>(&property),
+ std::move(animatorFunction),
+ alphaFunction,
+ timePeriod);
}
/**
- * From AnimatorBase.
+ * @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha )
*/
- virtual void Update( BufferIndex bufferIndex, float progress, bool bake )
+ void DoUpdate(BufferIndex bufferIndex, bool bake, float alpha) final
{
- float alpha = ApplyAlphaFunction(progress);
+ const PropertyType& current = mPropertyAccessor.Get(bufferIndex);
- const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
+ // need to cast the return value in case property is integer
+ const PropertyType result = static_cast<PropertyType>(mAnimatorFunction(alpha, current));
- 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 )
+ AnimatorTransformProperty(PropertyOwner* propertyOwner,
+ PropertyBase* property,
+ AnimatorFunction animatorFunction,
+ AlphaFunction alphaFunction,
+ const TimePeriod& timePeriod)
+ : AnimatorBase(propertyOwner, alphaFunction, timePeriod),
+ mAnimatorFunction(std::move(animatorFunction)),
+ mPropertyAccessor(property)
{
- mPropertyOwner->AddObserver(*this);
+ // WARNING - this object is created in the event-thread
+ // The scene-graph mPropertyOwner object cannot be observed here
}
// Undefined
- Animator( const Animator& );
-
- // Undefined
- Animator& operator=( const Animator& );
+ 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)
{
}
- 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<float>(property) + static_cast<float>(mRelative) * alpha);
}
- int mRelative;
+ int32_t mRelative;
};
-struct AnimateToInteger : public AnimatorFunctionBase
+struct AnimateToInteger
{
AnimateToInteger(const int& targetValue)
: mTarget(targetValue)
{
}
- 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<float>(property) + (static_cast<float>(mTarget - property) * alpha));
}
- int mTarget;
+ int32_t mTarget;
};
-struct AnimateByFloat : public AnimatorFunctionBase
+struct AnimateByFloat
{
AnimateByFloat(const float& relativeValue)
: mRelative(relativeValue)
float mRelative;
};
-struct AnimateToFloat : public AnimatorFunctionBase
+struct AnimateToFloat
{
AnimateToFloat(const float& targetValue)
: mTarget(targetValue)
float mTarget;
};
-struct AnimateByVector2 : public AnimatorFunctionBase
+struct AnimateByVector2
{
AnimateByVector2(const Vector2& relativeValue)
: mRelative(relativeValue)
Vector2 mRelative;
};
-struct AnimateToVector2 : public AnimatorFunctionBase
+struct AnimateToVector2
{
AnimateToVector2(const Vector2& targetValue)
: mTarget(targetValue)
Vector2 mTarget;
};
-struct AnimateByVector3 : public AnimatorFunctionBase
+struct AnimateByVector3
{
AnimateByVector3(const Vector3& relativeValue)
: mRelative(relativeValue)
Vector3 mRelative;
};
-struct AnimateToVector3 : public AnimatorFunctionBase
+struct AnimateToVector3
{
AnimateToVector3(const Vector3& targetValue)
: mTarget(targetValue)
Vector3 mTarget;
};
-struct AnimateByVector4 : public AnimatorFunctionBase
+struct AnimateByVector4
{
AnimateByVector4(const Vector4& relativeValue)
: mRelative(relativeValue)
Vector4 mRelative;
};
-struct AnimateToVector4 : public AnimatorFunctionBase
+struct AnimateToVector4
{
AnimateToVector4(const Vector4& targetValue)
: mTarget(targetValue)
Vector4 mTarget;
};
-struct AnimateByOpacity : public AnimatorFunctionBase
+struct AnimateByOpacity
{
AnimateByOpacity(const float& relativeValue)
: mRelative(relativeValue)
float mRelative;
};
-struct AnimateToOpacity : public AnimatorFunctionBase
+struct AnimateToOpacity
{
AnimateToOpacity(const float& targetValue)
: mTarget(targetValue)
float mTarget;
};
-struct AnimateByBoolean : public AnimatorFunctionBase
+struct AnimateByBoolean
{
AnimateByBoolean(bool relativeValue)
: mRelative(relativeValue)
bool mRelative;
};
-struct AnimateToBoolean : public AnimatorFunctionBase
+struct AnimateToBoolean
{
AnimateToBoolean(bool targetValue)
: mTarget(targetValue)
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)
{
}
Quaternion operator()(float alpha, const Quaternion& rotation)
{
- if (alpha > 0.0f)
+ if(alpha > 0.0f)
{
return rotation * Quaternion(mAngleRadians * alpha, mAxis);
}
return rotation;
}
- Radian mAngleRadians;
+ Radian mAngleRadians;
Vector3 mAxis;
};
-struct RotateToQuaternion : public AnimatorFunctionBase
+struct RotateToQuaternion
{
RotateToQuaternion(const Quaternion& targetValue)
: mTarget(targetValue)
Quaternion mTarget;
};
-
-struct KeyFrameBooleanFunctor : public AnimatorFunctionBase
+struct KeyFrameBooleanFunctor
{
- KeyFrameBooleanFunctor(KeyFrameBooleanPtr keyFrames)
- : mKeyFrames(keyFrames)
+ KeyFrameBooleanFunctor(KeyFrameBoolean keyFrames)
+ : mKeyFrames(std::move(keyFrames))
{
}
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)
{
}
- 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<float>(mKeyFrames.GetValue(progress, mInterpolation));
}
- return property;
+ return static_cast<float>(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)
{
}
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)
{
}
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)
{
}
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)
{
}
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))
{
}
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)
{
}
Vector3 operator()(float progress, const Vector3& property)
{
- return mPath->SamplePosition(progress );
+ Vector3 position(property);
+ static_cast<void>(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();
}
Quaternion operator()(float progress, const Quaternion& property)
{
- Vector3 tangent( mPath->SampleTangent(progress) );
- return Quaternion( mForward, tangent );
+ Vector3 tangent;
+ if(mPath->SampleTangent(progress, tangent))
+ {
+ return Quaternion(mForward, tangent);
+ }
+ else
+ {
+ return property;
+ }
}
PathPtr mPath;
Vector3 mForward;
};
-
} // namespace Internal
} // namespace Dali
-#endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__
+#endif // DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H
projects / platform / core / uifw / dali-core.git / blobdiff