#define __DALI_INTERNAL_SCENE_GRAPH_ANIMATION_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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.
* @param[in] durationSeconds The duration of the animation in seconds.
* @param[in] speedFactor Multiplier to the animation velocity.
* @param[in] playRange Minimum and maximum progress between which the animation will play.
- * @param[in] isLooping Whether the animation will loop.
+ * @param[in] loopCount The number of times the animation will loop. ( See SetLoopCount() )
* @param[in] endAction The action to perform when the animation ends.
* @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, bool isLooping, EndAction endAction, EndAction disconnectAction )
- {
- return new Animation( durationSeconds, speedFactor, playRange, isLooping, endAction, disconnectAction );
- }
+ static Animation* New( float durationSeconds, float speedFactor, const Vector2& playRange, int loopCount, EndAction endAction, EndAction disconnectAction );
/**
* Virtual destructor
virtual ~Animation();
/**
+ * Overriden delete operator
+ * Deletes the animation from its global memory pool
+ */
+ void operator delete( void* ptr );
+
+ /**
* Set the duration of an animation.
* @pre durationSeconds must be greater than zero.
* @param[in] durationSeconds The duration in seconds.
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.
*/
}
/**
- * Set whether the animation will loop.
- * @param[in] looping True if the animation will loop.
+ * Set the animation loop count.
+ * 0 is loop forever, N loop play N times
+ * @param[in] loopCount The loop count
*/
- void SetLooping(bool looping);
+ void SetLoopCount(int loopCount);
/**
* Query whether the animation will loop.
*/
bool IsLooping() const
{
- return mLooping;
+ return mLoopCount != 1;
+ }
+
+ /*
+ * Get the loop count
+ * @return the loop count
+ */
+ int GetLoopCount() const
+ {
+ return mLoopCount;
}
/**
*/
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 );
/**
+ * @brief Play the animation after a given delay time.
+ * @param[in] delaySeconds The delay time
+ */
+ void PlayAfter( float delaySeconds );
+
+ /**
* Pause the animation.
*/
void Pause();
* 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 GetPlayCount() const
+ int GetPlayedCount() const
{
- return mPlayCount;
+ return mPlayedCount;
+ }
+
+ /**
+ * Get the current loop count from zero to GetLoopCount().
+ */
+ int GetCurrentLoop() const
+ {
+ return mCurrentLoop;
}
/**
* @param[in] propertyOwner The scene-object that owns the animatable property.
* @post The animator is owned by this animation.
*/
- void AddAnimator( AnimatorBase* animator );
+ void AddAnimator( OwnerPointer<AnimatorBase>& animator );
/**
* Retrieve the animators from an animation.
* @pre The animation is playing or paused.
* @param[in] bufferIndex The buffer to update.
* @param[in] elapsedSeconds The time elapsed since the previous frame.
- * @return True if the animation has finished.
+ * @param[out] looped True if the animation looped
+ * @param[out] finished True if the animation has finished.
+ * @param[out] progressReached True if progress marker reached
*/
- bool Update(BufferIndex bufferIndex, float elapsedSeconds);
+ void Update(BufferIndex bufferIndex, float elapsedSeconds, bool& looped, bool& finished, bool& progressReached );
protected:
/**
* Protected constructor. See New()
*/
- Animation( float durationSeconds, float speedFactor, const Vector2& playRange, bool isLooping, EndAction endAction, EndAction disconnectAction );
+ Animation( float durationSeconds, float speedFactor, const Vector2& playRange, int loopCount, EndAction endAction, EndAction disconnectAction );
private:
protected:
+ AnimatorContainer mAnimators;
+
+ Vector2 mPlayRange;
+
float mDurationSeconds;
+ float mDelaySeconds;
+ float mElapsedSeconds;
float mSpeedFactor;
- bool mLooping;
+ float mProgressMarker; // Progress marker to trigger a notification
+
+ 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
+
EndAction mEndAction;
EndAction mDisconnectAction;
State mState;
- float mElapsedSeconds;
- int mPlayCount;
- Vector2 mPlayRange;
- AnimatorContainer mAnimators;
+ bool mProgressReachedSignalRequired; // Flag to indicate the progress marker was hit
};
}; //namespace SceneGraph
new (slot) LocalType( &animation, &Animation::SetDuration, durationSeconds );
}
-inline void SetLoopingMessage( EventThreadServices& eventThreadServices, const Animation& animation, bool looping )
+inline void SetProgressNotificationMessage( EventThreadServices& eventThreadServices, const Animation& animation, float progress )
{
- typedef MessageValue1< Animation, bool > LocalType;
+ typedef MessageValue1< Animation, float > LocalType;
// Reserve some memory inside the message queue
unsigned int* 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::SetLooping, looping );
+ new (slot) LocalType( &animation, &Animation::SetProgressNotification, progress );
+}
+
+
+inline void SetLoopingMessage( EventThreadServices& eventThreadServices, const Animation& animation, int loopCount )
+{
+ typedef MessageValue1< Animation, int > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* 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 );
}
inline void SetEndActionMessage( EventThreadServices& eventThreadServices, const Animation& animation, Dali::Animation::EndAction action )
unsigned int* 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 );
+ OwnerPointer<AnimatorBase> parameter( &animator );
+ new (slot) LocalType( &animation, &Animation::AddAnimator, parameter );
}
+inline void PlayAfterMessage( EventThreadServices& eventThreadServices, const Animation& animation, float delaySeconds )
+{
+ typedef MessageValue1< Animation, float > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* 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 );
+}
} // namespace SceneGraph
projects / platform / core / uifw / dali-core.git / blobdiff