X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fanimation%2Fscene-graph-animation.h;h=869fe2fa5b3381e517ffa71e735ba9db13f995bf;hb=8c0647a4a24b25a7e25c2b28559013fe4eadc6d2;hp=1885560f3018a8683c3e30e7efef3a649f9eb1c9;hpb=252e273f4e0cedbf35c42a752213b5193d883f47;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/animation/scene-graph-animation.h b/dali/internal/update/animation/scene-graph-animation.h index 1885560..869fe2f 100644 --- a/dali/internal/update/animation/scene-graph-animation.h +++ b/dali/internal/update/animation/scene-graph-animation.h @@ -1,8 +1,8 @@ -#ifndef __DALI_INTERNAL_SCENE_GRAPH_ANIMATION_H__ -#define __DALI_INTERNAL_SCENE_GRAPH_ANIMATION_H__ +#ifndef DALI_INTERNAL_SCENE_GRAPH_ANIMATION_H +#define DALI_INTERNAL_SCENE_GRAPH_ANIMATION_H /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2024 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. @@ -24,34 +24,24 @@ #include #include #include +#include #include namespace Dali { - namespace Internal { - namespace SceneGraph { - -class Animation; - -typedef OwnerContainer< Animation* > AnimationContainer; - -typedef AnimationContainer::Iterator AnimationIter; -typedef AnimationContainer::ConstIterator AnimationConstIter; - /** * Animations are used to change the properties of scene graph objects, as part of a scene * managers "update" phase. An animation is a container of Animator objects; the actual setting * of object values is done by the animators. */ -class Animation +class Animation : public NotifierInterface { public: - - typedef Dali::Animation::EndAction EndAction; + using EndAction = Dali::Animation::EndAction; enum State { @@ -71,7 +61,7 @@ public: * @param[in] disconnectAction The action to perform when the property owner of an animator is disconnected. * @return A new Animation */ - static Animation* New( float durationSeconds, float speedFactor, const Vector2& playRange, int loopCount, EndAction endAction, EndAction disconnectAction ); + static Animation* New(float durationSeconds, float speedFactor, const Vector2& playRange, int32_t loopCount, EndAction endAction, EndAction disconnectAction); /** * Virtual destructor @@ -82,7 +72,7 @@ public: * Overriden delete operator * Deletes the animation from its global memory pool */ - void operator delete( void* ptr ); + void operator delete(void* ptr); /** * Set the duration of an animation. @@ -92,6 +82,12 @@ public: void SetDuration(float durationSeconds); /** + * Set the progress marker to trigger notification + * @param[in] progress percent of progress to trigger notification, 0.0f < progress <= 1.0f + */ + void SetProgressNotification(float progress); + + /** * Retrieve the duration of the animation. * @return The duration in seconds. */ @@ -100,13 +96,13 @@ public: return mDurationSeconds; } - /* + /** * Retrieve the current progress of the animation. * @return The current progress as a normalized value between [0,1]. */ float GetCurrentProgress() const { - if( mDurationSeconds > 0.0f ) + if(mDurationSeconds > 0.0f) { return mElapsedSeconds / mDurationSeconds; } @@ -114,16 +110,20 @@ public: return 0.0f; } - /* + /** * Sets the progress of the animation. * @param[in] The new progress as a normalized value between [0,1] */ - void SetCurrentProgress( float progress ) + void SetCurrentProgress(float progress) { mElapsedSeconds = mDurationSeconds * progress; } - void SetSpeedFactor( float factor ) + /** + * Specifies a speed factor for the animation. + * @param[in] factor A value which will multiply the velocity + */ + void SetSpeedFactor(float factor) { mSpeedFactor = factor; } @@ -133,7 +133,7 @@ public: * 0 is loop forever, N loop play N times * @param[in] loopCount The loop count */ - void SetLoopCount(int loopCount); + void SetLoopCount(int32_t loopCount); /** * Query whether the animation will loop. @@ -144,11 +144,11 @@ public: return mLoopCount != 1; } - /* + /** * Get the loop count * @return the loop count */ - int GetLoopCount() const + int32_t GetLoopCount() const { return mLoopCount; } @@ -191,18 +191,33 @@ public: * * @param[in] range Two values between [0,1] to specify minimum and maximum progress. */ - void SetPlayRange( const Vector2& range ); + void SetPlayRange(const Vector2& range); + + /** + * @brief Sets the blend point to interpolate animate property + * + * @param[in] blendPoint A value between [0,1], If the value of the keyframe whose progress is 0 is different from the current value, + * the property is animated as it smoothly blends until the progress reaches the blendPoint. + * @note The blendPoint only affects animation registered with AnimateBetween. Other animations operate the same as when Play() is called. + */ + void SetBlendPoint(float blendPoint); /** * Play the animation. */ void Play(); - /* + /** * Play the animation from a given point * @param[in] progress A value between [0,1] form where the animation should start playing */ - void PlayFrom( float progress ); + void PlayFrom(float progress); + + /** + * @brief Play the animation after a given delay time. + * @param[in] delaySeconds The delay time + */ + void PlayAfter(float delaySeconds); /** * Pause the animation. @@ -217,6 +232,12 @@ public: bool Stop(BufferIndex bufferIndex); /** + * Clear the animator. It will stop animation, clear all animators, and make this animation never played before. + * @param[in] bufferIndex The buffer to update when mEndAction == Bake. + */ + void ClearAnimator(BufferIndex bufferIndex); + + /** * Called shortly before the animation is destroyed. * @param[in] bufferIndex The buffer to update when mEndAction == Bake. */ @@ -236,7 +257,7 @@ public: * Retrive a count of the number of times the animation has been played to completion. * This can be used to emit "Finised" signals from the public-api */ - int GetPlayedCount() const + int32_t GetPlayedCount() const { return mPlayedCount; } @@ -244,57 +265,65 @@ public: /** * Get the current loop count from zero to GetLoopCount(). */ - int GetCurrentLoop() const + int32_t GetCurrentLoop() const { return mCurrentLoop; } /** + * Query whether the animation is currently active (i.e. at least one of the animators has been updated in either frame) + * @return True if the animation is currently active + */ + bool IsActive() const + { + // As we have double buffering, if animator is updated in either frame, it needs to be rendered. + return mIsActive[0] || mIsActive[1]; + } + + /** + * @brief Sets the looping mode. + * + * Animation plays forwards and then restarts from the beginning or runs backwards again. + * @param[in] loopingMode True when the looping mode is AUTO_REVERSE + */ + void SetLoopingMode(bool loopingMode); + + /** * Add a newly created animator. * Animators are automatically removed, when orphaned from an animatable scene object. * @param[in] animator The animator to add. * @param[in] propertyOwner The scene-object that owns the animatable property. * @post The animator is owned by this animation. */ - void AddAnimator( AnimatorBase* animator ); - - /** - * Retrieve the animators from an animation. - * @return The container of animators. - */ - AnimatorContainer& GetAnimators() - { - return mAnimators; - } + void AddAnimator(OwnerPointer& animator); /** * This causes the animators to change the properties of objects in the scene graph. * @pre The animation is playing or paused. * @param[in] bufferIndex The buffer to update. * @param[in] elapsedSeconds The time elapsed since the previous frame. - * @param[out] looped True if the animation looped + * @param[out] stopped True if the animation stopped this loop * @param[out] finished True if the animation has finished. + * @param[out] progressReached True if progress marker reached */ - void Update(BufferIndex bufferIndex, float elapsedSeconds, bool& looped, bool& finished ); + void Update(BufferIndex bufferIndex, float elapsedSeconds, bool& stopped, bool& finished, bool& progressReached); + static uint32_t GetMemoryPoolCapacity(); protected: - /** * Protected constructor. See New() */ - Animation( float durationSeconds, float speedFactor, const Vector2& playRange, int loopCount, EndAction endAction, EndAction disconnectAction ); - + Animation(float durationSeconds, float speedFactor, const Vector2& playRange, int32_t loopCount, EndAction endAction, EndAction disconnectAction); private: - /** * Helper for Update, also used to bake when the animation is stopped or destroyed. * @param[in] bufferIndex The buffer to update. * @param[in] bake True if the final result should be baked. * @param[in] animationFinished True if the animation has finished. */ - void UpdateAnimators( BufferIndex bufferIndex, bool bake, bool animationFinished ); + void UpdateAnimators(BufferIndex bufferIndex, bool bake, bool animationFinished); /** * Helper function to bake the result of the animation when it is stopped or @@ -302,13 +331,13 @@ private: * @param[in] bufferIndex The buffer to update. * @param[in] action The end action specified. */ - void Bake(BufferIndex bufferIndex, EndAction action ); + void Bake(BufferIndex bufferIndex, EndAction action); /** * Helper function to set active state of animators. * @param[in] active Every animator is set to this state */ - void SetAnimatorsActive( bool active ); + void SetAnimatorsActive(bool active); // Undefined Animation(const Animation&); @@ -317,154 +346,212 @@ private: Animation& operator=(const Animation& rhs); protected: + OwnerContainer mAnimators; + + Vector2 mPlayRange; float mDurationSeconds; + float mDelaySeconds; + float mElapsedSeconds; float mSpeedFactor; + float mProgressMarker; // Progress marker to trigger a notification + float mBlendPoint; + + int32_t mPlayedCount; // Incremented at end of animation or completion of all loops + // Never incremented when looping forever. Event thread tracks to signal end. + int32_t mLoopCount; // N loop setting + int32_t mCurrentLoop; // Current loop number + EndAction mEndAction; EndAction mDisconnectAction; State mState; - float mElapsedSeconds; - int mPlayedCount; // Incremented at end of animation or completion of all loops - // Never incremented when looping forever. Event thread tracks to signal end. - int mLoopCount; // N loop setting - int mCurrentLoop; // Current loop number - Vector2 mPlayRange; - AnimatorContainer mAnimators; + bool mProgressReachedSignalRequired; // Flag to indicate the progress marker was hit + bool mAutoReverseEnabled; // Flag to identify that the looping mode is auto reverse. + bool mAnimatorSortRequired; // Flag to whether we need to sort animator or not. + bool mIsActive[2]; // Flag to indicate whether the animation is active in the current frame (which is double buffered) + bool mIsFirstLoop; + bool mIsStopped; // Flag to whether this animation call stoped by user at this frame. }; -}; //namespace SceneGraph +}; // namespace SceneGraph // value types used by messages -template <> struct ParameterType< Dali::Animation::EndAction > : public BasicType< Dali::Animation::EndAction > {}; +template<> +struct ParameterType : public BasicType +{ +}; namespace SceneGraph { - // Messages for Animation -inline void SetDurationMessage( EventThreadServices& eventThreadServices, const Animation& animation, float durationSeconds ) +inline void SetDurationMessage(EventThreadServices& eventThreadServices, const Animation& animation, float durationSeconds) +{ + using LocalType = MessageValue1; + + // Reserve some memory inside the message queue + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); + + // Construct message in the message queue memory; note that delete should not be called on the return value + new(slot) LocalType(&animation, &Animation::SetDuration, durationSeconds); +} + +inline void SetProgressNotificationMessage(EventThreadServices& eventThreadServices, const Animation& animation, float progress) { - typedef MessageValue1< Animation, float > LocalType; + using LocalType = MessageValue1; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::SetDuration, durationSeconds ); + new(slot) LocalType(&animation, &Animation::SetProgressNotification, progress); } -inline void SetLoopingMessage( EventThreadServices& eventThreadServices, const Animation& animation, int loopCount ) +inline void SetLoopingMessage(EventThreadServices& eventThreadServices, const Animation& animation, int32_t loopCount) { - typedef MessageValue1< Animation, int > LocalType; + using LocalType = MessageValue1; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::SetLoopCount, loopCount ); + new(slot) LocalType(&animation, &Animation::SetLoopCount, loopCount); } -inline void SetEndActionMessage( EventThreadServices& eventThreadServices, const Animation& animation, Dali::Animation::EndAction action ) +inline void SetEndActionMessage(EventThreadServices& eventThreadServices, const Animation& animation, Dali::Animation::EndAction action) { - typedef MessageValue1< Animation, Dali::Animation::EndAction > LocalType; + using LocalType = MessageValue1; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::SetEndAction, action ); + new(slot) LocalType(&animation, &Animation::SetEndAction, action); } -inline void SetDisconnectActionMessage( EventThreadServices& eventThreadServices, const Animation& animation, Dali::Animation::EndAction action ) +inline void SetDisconnectActionMessage(EventThreadServices& eventThreadServices, const Animation& animation, Dali::Animation::EndAction action) { - typedef MessageValue1< Animation, Dali::Animation::EndAction > LocalType; + using LocalType = MessageValue1; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::SetDisconnectAction, action ); + new(slot) LocalType(&animation, &Animation::SetDisconnectAction, action); } -inline void SetCurrentProgressMessage( EventThreadServices& eventThreadServices, const Animation& animation, float progress ) +inline void SetCurrentProgressMessage(EventThreadServices& eventThreadServices, const Animation& animation, float progress) { - typedef MessageValue1< Animation, float > LocalType; + using LocalType = MessageValue1; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::SetCurrentProgress, progress ); + new(slot) LocalType(&animation, &Animation::SetCurrentProgress, progress); } -inline void SetSpeedFactorMessage( EventThreadServices& eventThreadServices, const Animation& animation, float factor ) +inline void SetSpeedFactorMessage(EventThreadServices& eventThreadServices, const Animation& animation, float factor) { - typedef MessageValue1< Animation, float > LocalType; + using LocalType = MessageValue1; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::SetSpeedFactor, factor ); + new(slot) LocalType(&animation, &Animation::SetSpeedFactor, factor); } -inline void SetPlayRangeMessage( EventThreadServices& eventThreadServices, const Animation& animation, const Vector2& range ) +inline void SetPlayRangeMessage(EventThreadServices& eventThreadServices, const Animation& animation, const Vector2& range) { - typedef MessageValue1< Animation, Vector2 > LocalType; + using LocalType = MessageValue1; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::SetPlayRange, range ); + new(slot) LocalType(&animation, &Animation::SetPlayRange, range); } -inline void PlayAnimationMessage( EventThreadServices& eventThreadServices, const Animation& animation ) +inline void SetBlendPointMessage(EventThreadServices& eventThreadServices, const Animation& animation, float blendPoint) { - typedef Message< Animation > LocalType; + using LocalType = MessageValue1; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::Play ); + new(slot) LocalType(&animation, &Animation::SetBlendPoint, blendPoint); } -inline void PlayAnimationFromMessage( EventThreadServices& eventThreadServices, const Animation& animation, float progress ) +inline void PlayAnimationMessage(EventThreadServices& eventThreadServices, const Animation& animation) { - typedef MessageValue1< Animation,float > LocalType; + using LocalType = Message; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::PlayFrom, progress ); + new(slot) LocalType(&animation, &Animation::Play); } -inline void PauseAnimationMessage( EventThreadServices& eventThreadServices, const Animation& animation ) +inline void PlayAnimationFromMessage(EventThreadServices& eventThreadServices, const Animation& animation, float progress) { - typedef Message< Animation > LocalType; + using LocalType = MessageValue1; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::Pause ); + new(slot) LocalType(&animation, &Animation::PlayFrom, progress); } -inline void AddAnimatorMessage( EventThreadServices& eventThreadServices, const Animation& animation, AnimatorBase& animator ) +inline void PauseAnimationMessage(EventThreadServices& eventThreadServices, const Animation& animation) { - typedef MessageValue1< Animation, OwnerPointer > LocalType; + using LocalType = Message; // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &animation, &Animation::AddAnimator, &animator ); + new(slot) LocalType(&animation, &Animation::Pause); } +inline void AddAnimatorMessage(EventThreadServices& eventThreadServices, const Animation& animation, AnimatorBase& animator) +{ + using LocalType = MessageValue1 >; + + // Reserve some memory inside the message queue + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); + + // Construct message in the message queue memory; note that delete should not be called on the return value + OwnerPointer parameter(&animator); + new(slot) LocalType(&animation, &Animation::AddAnimator, parameter); +} + +inline void PlayAfterMessage(EventThreadServices& eventThreadServices, const Animation& animation, float delaySeconds) +{ + using LocalType = MessageValue1; + + // Reserve some memory inside the message queue + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); + + // Construct message in the message queue memory; note that delete should not be called on the return value + new(slot) LocalType(&animation, &Animation::PlayAfter, delaySeconds); +} + +inline void SetLoopingModeMessage(EventThreadServices& eventThreadServices, const Animation& animation, bool loopingMode) +{ + using LocalType = MessageValue1; + + // Reserve some memory inside the message queue + uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); + + // Construct message in the message queue memory; note that delete should not be called on the return value + new(slot) LocalType(&animation, &Animation::SetLoopingMode, loopingMode); +} } // namespace SceneGraph @@ -472,4 +559,4 @@ inline void AddAnimatorMessage( EventThreadServices& eventThreadServices, const } // namespace Dali -#endif // __DALI_INTERNAL_SCENE_GRAPH_ANIMATION_H__ +#endif // DALI_INTERNAL_SCENE_GRAPH_ANIMATION_H