// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/property-array.h>
+#include <dali/public-api/math/math-utils.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::~VectorAnimationTask: destructor [%p]\n", this );
}
+void VectorAnimationTask::Finalize()
+{
+ // Release some objects in the main thread
+ if( mAnimationFinishedTrigger )
+ {
+ mAnimationFinishedTrigger.reset();
+ }
+
+ mVectorRenderer.Finalize();
+}
+
void VectorAnimationTask::SetRenderer( Renderer renderer )
{
ConditionalWait::ScopedLock lock( mConditionalWait );
void VectorAnimationTask::SetAnimationFinishedCallback( EventThreadCallback* callback )
{
ConditionalWait::ScopedLock lock( mConditionalWait );
- mAnimationFinishedTrigger = std::unique_ptr< EventThreadCallback >( callback );
+ if( callback )
+ {
+ mAnimationFinishedTrigger = std::unique_ptr< EventThreadCallback >( callback );
+ }
}
void VectorAnimationTask::SetLoopCount( int32_t count )
}
}
-void VectorAnimationTask::SetPlayRange( uint32_t startFrame, uint32_t endFrame )
+void VectorAnimationTask::SetPlayRange( Property::Array& playRange )
{
+ ConditionalWait::ScopedLock lock( mConditionalWait );
+
+ bool valid = false;
+ uint32_t startFrame = 0, endFrame = 0;
+ size_t count = playRange.Count();
+
+ if( count >= 2 )
+ {
+ int32_t start = 0, end = 0;
+ if( playRange.GetElementAt( 0 ).Get( start ) && playRange.GetElementAt( 1 ).Get( end ) )
+ {
+ startFrame = static_cast< uint32_t >( start );
+ endFrame = static_cast< uint32_t >( end );
+ valid = true;
+ }
+ else
+ {
+ std::string startMarker, endMarker;
+ if( playRange.GetElementAt( 0 ).Get( startMarker ) && playRange.GetElementAt( 1 ).Get( endMarker ) )
+ {
+ if( mVectorRenderer )
+ {
+ uint32_t frame; // We don't use this later
+ if( mVectorRenderer.GetMarkerInfo( startMarker, startFrame, frame ) && mVectorRenderer.GetMarkerInfo( endMarker, frame, endFrame ) )
+ {
+ valid = true;
+ }
+ }
+ }
+ }
+ }
+ else if( count == 1 )
+ {
+ std::string marker;
+ if( playRange.GetElementAt( 0 ).Get( marker ) )
+ {
+ if( mVectorRenderer )
+ {
+ mVectorRenderer.GetMarkerInfo( marker, startFrame, endFrame );
+ valid = true;
+ }
+ }
+ }
+
+ if( !valid )
+ {
+ DALI_LOG_ERROR( "VectorAnimationTask::SetPlayRange: Invalid range [%p]\n", this );
+ return;
+ }
+
// Make sure the range specified is between 0 and the total frame number
- if( ( startFrame < mTotalFrame ) && ( endFrame < mTotalFrame ) )
+ if( startFrame >= 0 && startFrame < mTotalFrame && endFrame >= 0 && endFrame < mTotalFrame )
{
// If the range is not in order swap values
if( startFrame > endFrame )
if( startFrame != mStartFrame || endFrame != mEndFrame )
{
- ConditionalWait::ScopedLock lock( mConditionalWait );
-
mStartFrame = startFrame;
mEndFrame = endFrame;
DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetPlayRange: [%d, %d] [%p]\n", mStartFrame, mEndFrame, this );
}
}
+ else
+ {
+ DALI_LOG_ERROR( "VectorAnimationTask::SetPlayRange: Invalid range (%d, %d) [%p]\n", startFrame, endFrame, this );
+ return;
+ }
}
void VectorAnimationTask::GetPlayRange( uint32_t& startFrame, uint32_t& endFrame )
mCurrentFrame = frameNumber;
mCurrentFrameUpdated = true;
+ mUpdateFrameNumber = false;
mResourceReady = false;
DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::SetCurrentFrameNumber: frame number = %d [%p]\n", mCurrentFrame, this );
if( mPlayState == PlayState::PLAYING && mUpdateFrameNumber )
{
mCurrentFrame = mForward ? mCurrentFrame + 1 : mCurrentFrame - 1;
+ Dali::ClampInPlace( mCurrentFrame, mStartFrame, mEndFrame );
}
currentFrame = mCurrentFrame;
}
// Rasterize
- bool renderSuccess = mVectorRenderer.Render( currentFrame );
- if( !renderSuccess )
+ bool renderSuccess = false;
+ if( mVectorRenderer )
{
- DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Rasterize: Rendering failed. Try again later.[%d] [%p]\n", currentFrame, this );
- mUpdateFrameNumber = false;
+ renderSuccess = mVectorRenderer.Render( currentFrame );
+ if( !renderSuccess )
+ {
+ DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorAnimationTask::Rasterize: Rendering failed. Try again later.[%d] [%p]\n", currentFrame, this );
+ mUpdateFrameNumber = false;
+ }
}
if( stopped && renderSuccess )
std::chrono::time_point< std::chrono::system_clock > VectorAnimationTask::CalculateNextFrameTime( bool renderNow )
{
- mNextFrameStartTime = mNextFrameStartTime + std::chrono::nanoseconds( mFrameDurationNanoSeconds );
+ // std::chrono::time_point template has second parameter duration which defaults to the std::chrono::system_clock supported
+ // duration. In some C++11 implementations it is a milliseconds duration, so it fails to compile unless mNextFrameStartTime
+ // is casted to use the default duration.
+ mNextFrameStartTime = std::chrono::time_point_cast< std::chrono::time_point< std::chrono::system_clock >::duration >(
+ mNextFrameStartTime + std::chrono::nanoseconds( mFrameDurationNanoSeconds ) );
auto current = std::chrono::system_clock::now();
if( renderNow || mNextFrameStartTime < current )
{