// EXTERNAL INCLUDES
#include <dali/public-api/common/stage.h>
-#include <dali/devel-api/common/stage-devel.h>
+#include <dali/devel-api/rendering/renderer-devel.h>
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
-#include <dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.h>
namespace Dali
{
namespace
{
-const Dali::Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
constexpr auto LOOP_FOREVER = -1;
+const Dali::Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
+
+// Flags for re-sending data to the rasterize thread
+enum Flags
+{
+ RESEND_PLAY_RANGE = 1 << 0,
+ RESEND_LOOP_COUNT = 1 << 1
+};
+
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_VECTOR_ANIMATION" );
+#endif
+
} // unnamed namespace
AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties )
: Visual::Base( factoryCache, Visual::FittingMode::FILL ),
mImageVisualShaderFactory( shaderFactory ),
mUrl( imageUrl ),
+ mVectorRasterizeThread( imageUrl.GetUrl() ),
mVisualSize(),
- mPlayRange( 0.0f, 1.0f ),
mPlacementActor(),
- mVectorRasterizeThread(),
mLoopCount( LOOP_FOREVER ),
+ mStartFrame( 0 ),
+ mEndFrame( 0 ),
+ mResendFlag( 0 ),
mActionStatus( DevelAnimatedVectorImageVisual::Action::STOP )
{
// the rasterized image is with pre-multiplied alpha format
mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA;
+
+ mVectorRasterizeThread.SetResourceReadyCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnResourceReady ) ) );
+ mVectorRasterizeThread.SetAnimationFinishedCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnAnimationFinished ) ) );
+
+ mVectorRasterizeThread.Start();
}
AnimatedVectorImageVisual::~AnimatedVectorImageVisual()
void AnimatedVectorImageVisual::GetNaturalSize( Vector2& naturalSize )
{
- naturalSize = mVisualSize;
+ if( mImpl->mRenderer ) // Check if we have a rendered image
+ {
+ auto textureSet = mImpl->mRenderer.GetTextures();
+ if( textureSet )
+ {
+ if( textureSet.GetTextureCount() > 0 )
+ {
+ auto texture = textureSet.GetTexture( 0 );
+ naturalSize.x = texture.GetWidth();
+ naturalSize.y = texture.GetHeight();
+ return;
+ }
+ }
+ }
+
+ uint32_t width, height;
+ mVectorRasterizeThread.GetDefaultSize( width, height );
+ naturalSize.x = width;
+ naturalSize.y = height;
}
void AnimatedVectorImageVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Insert( Toolkit::ImageVisual::Property::URL, mUrl.GetUrl() );
}
- map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, static_cast< int >( mLoopCount ) );
- map.Insert( Toolkit::DevelImageVisual::Property::PLAY_RANGE, static_cast< Vector2 >( mPlayRange ) );
+ map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, mLoopCount );
- if( mVectorRasterizeThread )
- {
- map.Insert( Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast< int >( mVectorRasterizeThread->GetPlayState() ) );
- }
- else
- {
- map.Insert( Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast< int >( DevelImageVisual::PlayState::STOPPED ) );
- }
+ Property::Array playRange;
+ playRange.PushBack( mStartFrame );
+ playRange.PushBack( mEndFrame );
+ map.Insert( Toolkit::DevelImageVisual::Property::PLAY_RANGE, playRange );
+
+ map.Insert( Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast< int >( mVectorRasterizeThread.GetPlayState() ) );
+ map.Insert( Toolkit::DevelImageVisual::Property::CURRENT_FRAME_NUMBER, static_cast< int32_t >( mVectorRasterizeThread.GetCurrentFrameNumber() ) );
+ map.Insert( Toolkit::DevelImageVisual::Property::TOTAL_FRAME_NUMBER, static_cast< int32_t >( mVectorRasterizeThread.GetTotalFrameNumber() ) );
}
void AnimatedVectorImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
if( value.Get( loopCount ) )
{
mLoopCount = loopCount;
- if( mVectorRasterizeThread )
- {
- mVectorRasterizeThread->SetLoopCount( loopCount );
- }
+ mResendFlag |= RESEND_LOOP_COUNT;
}
break;
}
case Toolkit::DevelImageVisual::Property::PLAY_RANGE:
{
- Vector2 range;
- if( value.Get( range ) )
+ Property::Array* array = value.GetArray();
+ if( array )
{
- // Make sure the range specified is between 0.0 and 1.0
- if( range.x >= 0.0f && range.x <= 1.0f && range.y >= 0.0f && range.y <= 1.0f )
+ size_t count = array->Count();
+ if( count >= 2 )
{
- Vector2 orderedRange( range );
- // If the range is not in order swap values
- if( range.x > range.y )
+ int startFrame, endFrame;
+ int totalFrame = mVectorRasterizeThread.GetTotalFrameNumber();
+ array->GetElementAt( 0 ).Get( startFrame );
+ array->GetElementAt( 1 ).Get( endFrame );
+
+ if( startFrame >= 0 && startFrame < totalFrame && endFrame >= 0 && endFrame < totalFrame )
{
- orderedRange = Vector2( range.y, range.x );
+ mStartFrame = startFrame;
+ mEndFrame = endFrame;
+ mResendFlag |= RESEND_PLAY_RANGE;
}
-
- mPlayRange = orderedRange;
-
- if( mVectorRasterizeThread )
+ else
{
- mVectorRasterizeThread->SetPlayRange( mPlayRange );
+ DALI_LOG_ERROR( "Invalid play range [%d, %d / %d]\n", startFrame, endFrame, totalFrame );
}
}
}
// Hold the weak handle of the placement actor and delay the adding of renderer until the rasterization is finished.
mPlacementActor = actor;
- // This visual needs it's size set before it can be rasterized hence set ResourceReady once on stage
- ResourceReady( Toolkit::Visual::ResourceStatus::READY );
+ mVectorRasterizeThread.SetRenderer( mImpl->mRenderer );
}
void AnimatedVectorImageVisual::DoSetOffStage( Actor& actor )
{
- if( mVectorRasterizeThread )
- {
- mVectorRasterizeThread->PauseAnimation();
- DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::IF_REQUIRED );
- mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
- }
+ mVectorRasterizeThread.PauseAnimation();
+
+ mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
if( mImpl->mRenderer )
{
+ mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
+
actor.RemoveRenderer( mImpl->mRenderer );
mImpl->mRenderer.Reset();
}
if( IsOnStage() )
{
+ DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSetTransform: width = %f, height = %f\n", visualSize.width, visualSize.height );
+
if( visualSize != mVisualSize )
{
mVisualSize = visualSize;
- if( !mVectorRasterizeThread )
- {
- uint32_t width = static_cast< uint32_t >( visualSize.width );
- uint32_t height = static_cast< uint32_t >( visualSize.height );
+ uint32_t width = static_cast< uint32_t >( visualSize.width );
+ uint32_t height = static_cast< uint32_t >( visualSize.height );
- mVectorRasterizeThread = std::unique_ptr< VectorRasterizeThread >( new VectorRasterizeThread( mUrl.GetUrl(), mImpl->mRenderer, width, height ) );
+ mVectorRasterizeThread.SetSize( width, height );
+ }
- mVectorRasterizeThread->SetResourceReadyCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnResourceReady ) ) );
- mVectorRasterizeThread->SetAnimationFinishedCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnAnimationFinished ) ) );
- mVectorRasterizeThread->SetLoopCount( mLoopCount );
- mVectorRasterizeThread->SetPlayRange( mPlayRange );
+ SendAnimationData();
- mVectorRasterizeThread->Start();
+ if( mActionStatus == DevelAnimatedVectorImageVisual::Action::PLAY )
+ {
+ mVectorRasterizeThread.PlayAnimation();
- if( mActionStatus == DevelAnimatedVectorImageVisual::Action::PLAY )
- {
- mVectorRasterizeThread->StartAnimation();
- DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::CONTINUOUSLY );
- }
- else
- {
- // Render one frame
- mVectorRasterizeThread->RenderFrame();
- }
- }
- else
- {
- uint32_t width = static_cast< uint32_t >( visualSize.width );
- uint32_t height = static_cast< uint32_t >( visualSize.height );
+ mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY );
+ }
+ else
+ {
+ // Render one frame
+ mVectorRasterizeThread.RenderFrame();
+ }
- mVectorRasterizeThread->SetSize( width, height );
+ if( mVectorRasterizeThread.IsResourceReady() )
+ {
+ Actor actor = mPlacementActor.GetHandle();
+ if( actor )
+ {
+ actor.AddRenderer( mImpl->mRenderer );
+ mPlacementActor.Reset();
}
+
+ ResourceReady( Toolkit::Visual::ResourceStatus::READY );
}
}
}
{
case DevelAnimatedVectorImageVisual::Action::PLAY:
{
- if( IsOnStage())
+ if( IsOnStage() && mVisualSize != Vector2::ZERO )
{
- if( mVectorRasterizeThread )
- {
- mVectorRasterizeThread->StartAnimation();
- DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::CONTINUOUSLY ); //TODO: Should manage this globally
- }
+ mVectorRasterizeThread.PlayAnimation();
+
+ mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY );
}
mActionStatus = DevelAnimatedVectorImageVisual::Action::PLAY;
break;
}
case DevelAnimatedVectorImageVisual::Action::PAUSE:
{
- if( mVectorRasterizeThread )
+ mVectorRasterizeThread.PauseAnimation();
+
+ if( mImpl->mRenderer )
{
- mVectorRasterizeThread->PauseAnimation();
- DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::IF_REQUIRED );
+ mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
}
+
mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
break;
}
case DevelAnimatedVectorImageVisual::Action::STOP:
{
- if( mVectorRasterizeThread )
+ if( mVectorRasterizeThread.GetPlayState() != DevelImageVisual::PlayState::STOPPED )
{
- bool emitSignal = false;
- if( mVectorRasterizeThread->GetPlayState() != DevelImageVisual::PlayState::STOPPED )
- {
- emitSignal = true;
- }
+ mVectorRasterizeThread.StopAnimation();
- mVectorRasterizeThread->StopAnimation();
- DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::IF_REQUIRED );
+ OnAnimationFinished();
+ }
+ mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
+ break;
+ }
+ case DevelAnimatedVectorImageVisual::Action::JUMP_TO:
+ {
+ int32_t frameNumber;
+ if( attributes.Get( frameNumber ) )
+ {
+ mVectorRasterizeThread.SetCurrentFrameNumber( frameNumber );
- if( emitSignal )
+ if( IsOnStage() && mVectorRasterizeThread.GetPlayState() != DevelImageVisual::PlayState::PLAYING )
{
- OnAnimationFinished();
+ mVectorRasterizeThread.RenderFrame();
+ Stage::GetCurrent().KeepRendering( 0.0f ); // Trigger rendering
}
}
- mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
+ break;
+ }
+ case DevelAnimatedVectorImageVisual::Action::UPDATE_PROPERTY:
+ {
+ Property::Map* map = attributes.GetMap();
+ if( map )
+ {
+ DoSetProperties( *map );
+
+ SendAnimationData();
+ }
break;
}
}
// reset the weak handle so that the renderer only get added to actor once
mPlacementActor.Reset();
- Stage::GetCurrent().KeepRendering( 0.0f );
+ ResourceReady( Toolkit::Visual::ResourceStatus::READY );
}
}
{
mImpl->mEventObserver->NotifyVisualEvent( *this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED );
}
+
+ mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
+
+ if( mImpl->mRenderer )
+ {
+ mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
+ }
+}
+
+void AnimatedVectorImageVisual::SendAnimationData()
+{
+ if( mResendFlag )
+ {
+ bool isPlaying = false;
+ if( mVectorRasterizeThread.GetPlayState() == DevelImageVisual::PlayState::PLAYING )
+ {
+ mVectorRasterizeThread.PauseAnimation();
+ isPlaying = true;
+ }
+
+ if( mResendFlag & RESEND_LOOP_COUNT )
+ {
+ mVectorRasterizeThread.SetLoopCount( mLoopCount );
+ }
+
+ if( mResendFlag & RESEND_PLAY_RANGE )
+ {
+ mVectorRasterizeThread.SetPlayRange( mStartFrame, mEndFrame );
+ }
+
+ if( IsOnStage() )
+ {
+ if( isPlaying )
+ {
+ mVectorRasterizeThread.PlayAnimation();
+ }
+ else
+ {
+ mVectorRasterizeThread.RenderFrame();
+ Stage::GetCurrent().KeepRendering( 0.0f );
+ }
+ }
+
+ mResendFlag = 0;
+ }
}
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff