#define __DALI_INTERNAL_SCENE_GRAPH_ANIMATOR_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 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.
*/
// 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/common/property-base.h>
#include <dali/public-api/animation/alpha-function.h>
#include <dali/public-api/animation/animation.h>
#include <dali/public-api/animation/time-period.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/math/quaternion.h>
#include <dali/public-api/math/radian.h>
+#include <dali/devel-api/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/common/property-base.h>
+#include <dali/internal/update/animation/property-accessor.h>
+#include <dali/integration-api/debug.h>
namespace Dali
{
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),
+ : mLifecycleObserver(nullptr),
+ mDurationSeconds(1.0f),
+ mIntervalDelaySeconds(0.0f),
+ mSpeedFactor(1.0f),
+ mLoopCount(1),
mAlphaFunction(AlphaFunction::DEFAULT),
mDisconnectAction(Dali::Animation::BakeFinal),
- mActive(false),
+ mAnimationPlaying(false),
mEnabled(true),
- mConnectedToSceneGraph(false)
+ mConnectedToSceneGraph(false),
+ mAutoReverseEnabled( false )
{
}
*/
virtual ~AnimatorBase()
{
+ if( mLifecycleObserver != nullptr )
+ {
+ mLifecycleObserver->ObjectDestroyed();
+ }
+ }
+
+ void AddLifecycleObserver( LifecycleObserver& observer )
+ {
+ mLifecycleObserver = &observer;
+ }
+
+ void RemoveLifecycleObserver( LifecycleObserver& observer )
+ {
+ mLifecycleObserver = nullptr;
}
/**
* 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 upperBound(1.0f);
float currentT(0.5f);
float currentX = EvaluateCubicBezier( controlPoints.x, controlPoints.z, currentT);
- while( fabs( progress - currentX ) > tolerance )
+ while( fabsf( progress - currentX ) > tolerance )
{
if( progress > currentX )
{
*/
void SetActive( bool active )
{
- mActive = active;
+ mAnimationPlaying = active;
}
/**
- * Retrieve whether the animator has been set to active or not.
- * @return The active state.
- */
- bool GetActive() const
- {
- return mActive;
- }
-
- /*
* Retrive wheter the animator's target object is valid and on the stage.
* @return The enabled state.
*/
{
return mEnabled;
}
+
+ /**
+ * @brief Sets the looping mode.
+ * @param[in] loopingMode True when the looping mode is AUTO_REVERSE
+ */
+ void SetLoopingMode( bool loopingMode )
+ {
+ mAutoReverseEnabled = loopingMode;
+ }
+
/**
* Returns wheter the target object of the animator is still valid
* or has been destroyed.
return 3.0f*(1.0f-t)*(1.0f-t)*t*p0 + 3.0f*(1.0f-t)*tSquare*p1 + tSquare*t;
}
+ LifecycleObserver* mLifecycleObserver;
float mDurationSeconds;
- float mInitialDelaySeconds;
+ float mIntervalDelaySeconds;
+ float mSpeedFactor;
+
+ int32_t mLoopCount;
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 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;
};
/**
animatorFunction );
animator->SetAlphaFunction( alphaFunction );
- animator->SetInitialDelay( timePeriod.delaySeconds );
+ animator->SetIntervalDelay( timePeriod.delaySeconds );
animator->SetDuration( timePeriod.durationSeconds );
return animator;
mPropertyOwner->RemoveObserver(*this);
}
- if( mAnimatorFunction )
- {
- delete mAnimatorFunction;
- }
+ delete mAnimatorFunction;
}
/**
virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
{
// If we are active, then bake the value if required
- if ( mActive && mDisconnectAction != Dali::Animation::Discard )
+ 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 );
}
- mActive = false;
mEnabled = false;
}
virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
{
mPropertyOwner = NULL;
- mPropertyAccessor.Reset();
- mEnabled = false;
}
/**
*/
virtual void Update( BufferIndex bufferIndex, float progress, bool bake )
{
- float alpha = ApplyAlphaFunction(progress);
+ if( mLoopCount >= 0 )
+ {
+ // Update the progress value
+ progress = SetProgress( progress );
+ }
+
+ float alpha = ApplyAlphaFunction( progress );
const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
- const PropertyType result = (*mAnimatorFunction)( alpha, current );
+ // need to cast the return value in case property is integer
+ const PropertyType result = static_cast<PropertyType>( (*mAnimatorFunction)( alpha, current ) );
if ( bake )
{
mPropertyAccessor.Bake( bufferIndex, result );
float mCurrentProgress;
};
+
+
+/**
+ * An animator for a specific property type PropertyType.
+ */
+template <typename T, typename PropertyAccessorType>
+class AnimatorTransformProperty : public AnimatorBase, public PropertyOwner::Observer
+{
+public:
+
+ /**
+ * 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.
+ */
+ static AnimatorBase* New( const PropertyOwner& propertyOwner,
+ const PropertyBase& property,
+ AnimatorFunctionBase* 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*>( &propertyOwner ),
+ const_cast<PropertyBase*>( &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 ( 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.
+ */
+ virtual void Update( BufferIndex bufferIndex, float progress, bool bake )
+ {
+ if( mLoopCount >= 0 )
+ {
+ // Update the progress value
+ progress = SetProgress( progress );
+ }
+
+ float alpha = ApplyAlphaFunction( progress );
+
+ const T& current = mPropertyAccessor.Get( bufferIndex );
+
+ // need to cast the return value in case property is integer
+ T result = static_cast<T>( (*mAnimatorFunction)( alpha, current ) );
+
+ if ( bake )
+ {
+ mPropertyAccessor.Bake( bufferIndex, result );
+ }
+ else
+ {
+ 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 )
+ {
+ // 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& );
+
+protected:
+
+ PropertyOwner* mPropertyOwner;
+ PropertyAccessorType mPropertyAccessor;
+
+ AnimatorFunctionBase* mAnimatorFunction;
+ float mCurrentProgress;
+};
+
} // namespace SceneGraph
/*
return property;
}
- virtual float operator()(float progress, const int& property)
+ virtual float operator()(float progress, const int32_t& property)
{
- return property;
- }
-
- virtual float operator()(float progress, const unsigned int& property)
- {
- return property;
+ return static_cast<float>( property );
}
virtual float operator()(float progress, const float& property)
{
}
- float operator()(float alpha, const int& property)
+ using AnimatorFunctionBase::operator();
+ 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
{
}
- float operator()(float alpha, const int& property)
+ using AnimatorFunctionBase::operator();
+ 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
{
}
+ using AnimatorFunctionBase::operator();
float operator()(float alpha, const float& property)
{
return float(property + mRelative * alpha);
{
}
+ using AnimatorFunctionBase::operator();
float operator()(float alpha, const float& property)
{
return float(property + ((mTarget - property) * alpha));
{
}
+ using AnimatorFunctionBase::operator();
Vector2 operator()(float alpha, const Vector2& property)
{
return Vector2(property + mRelative * alpha);
{
}
+ using AnimatorFunctionBase::operator();
Vector2 operator()(float alpha, const Vector2& property)
{
return Vector2(property + ((mTarget - property) * alpha));
{
}
+ using AnimatorFunctionBase::operator();
Vector3 operator()(float alpha, const Vector3& property)
{
return Vector3(property + mRelative * alpha);
{
}
+ using AnimatorFunctionBase::operator();
Vector3 operator()(float alpha, const Vector3& property)
{
return Vector3(property + ((mTarget - property) * alpha));
{
}
+ using AnimatorFunctionBase::operator();
Vector4 operator()(float alpha, const Vector4& property)
{
return Vector4(property + mRelative * alpha);
{
}
+ using AnimatorFunctionBase::operator();
Vector4 operator()(float alpha, const Vector4& property)
{
return Vector4(property + ((mTarget - property) * alpha));
{
}
+ using AnimatorFunctionBase::operator();
Vector4 operator()(float alpha, const Vector4& property)
{
Vector4 result(property);
{
}
+ using AnimatorFunctionBase::operator();
Vector4 operator()(float alpha, const Vector4& property)
{
Vector4 result(property);
{
}
+ 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
{
}
+ 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
{
}
+ using AnimatorFunctionBase::operator();
Quaternion operator()(float alpha, const Quaternion& rotation)
{
if (alpha > 0.0f)
{
}
+ using AnimatorFunctionBase::operator();
Quaternion operator()(float alpha, const Quaternion& rotation)
{
return Quaternion::Slerp(rotation, mTarget, alpha);
{
}
+ using AnimatorFunctionBase::operator();
bool operator()(float progress, const bool& property)
{
if(mKeyFrames->IsActive(progress))
{
}
- float operator()(float progress, const int& property)
+ using AnimatorFunctionBase::operator();
+ float operator()(float progress, const int32_t& property)
{
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;
{
}
+ using AnimatorFunctionBase::operator();
float operator()(float progress, const float& property)
{
if(mKeyFrames->IsActive(progress))
{
}
+ using AnimatorFunctionBase::operator();
Vector2 operator()(float progress, const Vector2& property)
{
if(mKeyFrames->IsActive(progress))
{
}
+ using AnimatorFunctionBase::operator();
Vector3 operator()(float progress, const Vector3& property)
{
if(mKeyFrames->IsActive(progress))
{
}
+ using AnimatorFunctionBase::operator();
Vector4 operator()(float progress, const Vector4& property)
{
if(mKeyFrames->IsActive(progress))
{
}
+ using AnimatorFunctionBase::operator();
Quaternion operator()(float progress, const Quaternion& property)
{
if(mKeyFrames->IsActive(progress))
{
}
+ using AnimatorFunctionBase::operator();
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;
mForward.Normalize();
}
+ using AnimatorFunctionBase::operator();
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
projects / platform / core / uifw / dali-core.git / blobdiff