dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/common/stage.h>
  23 #include <dali/devel-api/rendering/renderer-devel.h>
  24 #include <dali/integration-api/debug.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  28 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  29 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  30 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  31 #include <dali-toolkit/devel-api/visuals/animated-vector-image-visual-signals-devel.h>
  32 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  33 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  34 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  35 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  36
  37 namespace Dali
  38 {
  39
  40 namespace Toolkit
  41 {
  42
  43 namespace Internal
  44 {
  45
  46 namespace
  47 {
  48
  49 constexpr auto LOOP_FOREVER = -1;
  50
  51 const Dali::Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
  52
  53 // Flags for re-sending data to the rasterize thread
  54 enum Flags
  55 {
  56   RESEND_PLAY_RANGE  = 1 << 0,
  57   RESEND_LOOP_COUNT  = 1 << 1
  58 };
  59
  60 } // unnamed namespace
  61
  62 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties )
  63 {
  64   AnimatedVectorImageVisualPtr visual( new AnimatedVectorImageVisual( factoryCache, shaderFactory, imageUrl ) );
  65   visual->SetProperties( properties );
  66
  67   return visual;
  68 }
  69
  70 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl )
  71 {
  72   AnimatedVectorImageVisualPtr visual( new AnimatedVectorImageVisual( factoryCache, shaderFactory, imageUrl ) );
  73
  74   return visual;
  75 }
  76
  77 AnimatedVectorImageVisual::AnimatedVectorImageVisual( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl )
  78 : Visual::Base( factoryCache ),
  79   mImageVisualShaderFactory( shaderFactory ),
  80   mUrl( imageUrl ),
  81   mVectorRasterizeThread( imageUrl.GetUrl() ),
  82   mVisualSize(),
  83   mPlayRange( 0.0f, 1.0f ),
  84   mPlacementActor(),
  85   mLoopCount( LOOP_FOREVER ),
  86   mResendFlag( 0 ),
  87   mActionStatus( DevelAnimatedVectorImageVisual::Action::STOP )
  88 {
  89   // the rasterized image is with pre-multiplied alpha format
  90   mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA;
  91
  92   mVectorRasterizeThread.SetResourceReadyCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnResourceReady ) ) );
  93   mVectorRasterizeThread.SetAnimationFinishedCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnAnimationFinished ) ) );
  94
  95   mVectorRasterizeThread.Start();
  96 }
  97
  98 AnimatedVectorImageVisual::~AnimatedVectorImageVisual()
  99 {
 100 }
 101
 102 void AnimatedVectorImageVisual::GetNaturalSize( Vector2& naturalSize )
 103 {
 104   naturalSize = mVisualSize;
 105 }
 106
 107 void AnimatedVectorImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 108 {
 109   map.Clear();
 110   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE );
 111   if( mUrl.IsValid() )
 112   {
 113     map.Insert( Toolkit::ImageVisual::Property::URL, mUrl.GetUrl() );
 114   }
 115   map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, mLoopCount );
 116   map.Insert( Toolkit::DevelImageVisual::Property::PLAY_RANGE, mPlayRange );
 117   map.Insert( Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast< int >( mVectorRasterizeThread.GetPlayState() ) );
 118   map.Insert( Toolkit::DevelImageVisual::Property::CURRENT_PROGRESS, mVectorRasterizeThread.GetCurrentProgress() );
 119 }
 120
 121 void AnimatedVectorImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 122 {
 123   // Do nothing
 124 }
 125
 126 void AnimatedVectorImageVisual::DoSetProperties( const Property::Map& propertyMap )
 127 {
 128   // url already passed in from constructor
 129   for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
 130   {
 131     KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
 132     if( keyValue.first.type == Property::Key::INDEX )
 133     {
 134       DoSetProperty( keyValue.first.indexKey, keyValue.second );
 135     }
 136     else
 137     {
 138        if( keyValue.first == LOOP_COUNT_NAME )
 139        {
 140           DoSetProperty( Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second );
 141        }
 142        else if( keyValue.first == PLAY_RANGE_NAME )
 143        {
 144           DoSetProperty( Toolkit::DevelImageVisual::Property::PLAY_RANGE, keyValue.second );
 145        }
 146     }
 147   }
 148 }
 149
 150 void AnimatedVectorImageVisual::DoSetProperty( Property::Index index, const Property::Value& value )
 151 {
 152   switch(index)
 153   {
 154     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
 155     {
 156       int32_t loopCount;
 157       if( value.Get( loopCount ) )
 158       {
 159         mLoopCount = loopCount;
 160         mResendFlag |= RESEND_LOOP_COUNT;
 161       }
 162       break;
 163     }
 164     case Toolkit::DevelImageVisual::Property::PLAY_RANGE:
 165     {
 166       Vector2 range;
 167       if( value.Get( range ) )
 168       {
 169         mPlayRange = range;
 170         mResendFlag |= RESEND_PLAY_RANGE;
 171       }
 172       break;
 173     }
 174   }
 175 }
 176
 177 void AnimatedVectorImageVisual::DoSetOnStage( Actor& actor )
 178 {
 179   Shader shader;
 180
 181   if( mImpl->mCustomShader )
 182   {
 183     shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource() : mImpl->mCustomShader->mVertexShader,
 184                           mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource() : mImpl->mCustomShader->mFragmentShader,
 185                           mImpl->mCustomShader->mHints );
 186
 187     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 188   }
 189   else
 190   {
 191     shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true );
 192   }
 193
 194   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 195
 196   mImpl->mRenderer = Renderer::New( geometry, shader );
 197
 198   TextureSet textureSet = TextureSet::New();
 199   mImpl->mRenderer.SetTextures( textureSet );
 200
 201   // Register transform properties
 202   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 203
 204   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 205
 206   // Hold the weak handle of the placement actor and delay the adding of renderer until the rasterization is finished.
 207   mPlacementActor = actor;
 208
 209   mVectorRasterizeThread.SetRenderer( mImpl->mRenderer );
 210 }
 211
 212 void AnimatedVectorImageVisual::DoSetOffStage( Actor& actor )
 213 {
 214   mVectorRasterizeThread.PauseAnimation();
 215
 216   mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
 217
 218   if( mImpl->mRenderer )
 219   {
 220     mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 221
 222     actor.RemoveRenderer( mImpl->mRenderer );
 223     mImpl->mRenderer.Reset();
 224   }
 225
 226   mPlacementActor.Reset();
 227
 228   // Reset the visual size to zero so that when adding the actor back to stage the rasterization is forced
 229   mVisualSize = Vector2::ZERO;
 230 }
 231
 232 void AnimatedVectorImageVisual::OnSetTransform()
 233 {
 234   Vector2 visualSize = mImpl->mTransform.GetVisualSize( mImpl->mControlSize );
 235
 236   if( IsOnStage() )
 237   {
 238     if( visualSize != mVisualSize )
 239     {
 240       mVisualSize = visualSize;
 241
 242       uint32_t width = static_cast< uint32_t >( visualSize.width );
 243       uint32_t height = static_cast< uint32_t >( visualSize.height );
 244
 245       mVectorRasterizeThread.SetSize( width, height );
 246     }
 247
 248     SendAnimationData();
 249
 250     if( mActionStatus == DevelAnimatedVectorImageVisual::Action::PLAY )
 251     {
 252       mVectorRasterizeThread.PlayAnimation();
 253
 254       mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY );
 255     }
 256     else
 257     {
 258       // Render one frame
 259       mVectorRasterizeThread.RenderFrame();
 260     }
 261
 262     if( mVectorRasterizeThread.IsResourceReady() )
 263     {
 264       Actor actor = mPlacementActor.GetHandle();
 265       if( actor )
 266       {
 267         actor.AddRenderer( mImpl->mRenderer );
 268         mPlacementActor.Reset();
 269       }
 270
 271       ResourceReady( Toolkit::Visual::ResourceStatus::READY );
 272     }
 273   }
 274 }
 275
 276 void AnimatedVectorImageVisual::OnDoAction( const Property::Index actionId, const Property::Value& attributes )
 277 {
 278   // Check if action is valid for this visual type and perform action if possible
 279   switch( actionId )
 280   {
 281     case DevelAnimatedVectorImageVisual::Action::PLAY:
 282     {
 283       if( IsOnStage() )
 284       {
 285         mVectorRasterizeThread.PlayAnimation();
 286
 287         mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY );
 288       }
 289       mActionStatus = DevelAnimatedVectorImageVisual::Action::PLAY;
 290       break;
 291     }
 292     case DevelAnimatedVectorImageVisual::Action::PAUSE:
 293     {
 294       mVectorRasterizeThread.PauseAnimation();
 295
 296       if( mImpl->mRenderer )
 297       {
 298         mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 299       }
 300
 301       mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
 302       break;
 303     }
 304     case DevelAnimatedVectorImageVisual::Action::STOP:
 305     {
 306       if( mVectorRasterizeThread.GetPlayState() != DevelImageVisual::PlayState::STOPPED )
 307       {
 308         mVectorRasterizeThread.StopAnimation();
 309
 310         OnAnimationFinished();
 311       }
 312       mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
 313       break;
 314     }
 315     case DevelAnimatedVectorImageVisual::Action::JUMP_TO:
 316     {
 317       float progress;
 318       if( attributes.Get( progress ) )
 319       {
 320         mVectorRasterizeThread.SetCurrentProgress( progress );
 321       }
 322       break;
 323     }
 324     case DevelAnimatedVectorImageVisual::Action::UPDATE_PROPERTY:
 325     {
 326       Property::Map* map = attributes.GetMap();
 327       if( map )
 328       {
 329         DoSetProperties( *map );
 330
 331         SendAnimationData();
 332       }
 333       break;
 334     }
 335   }
 336 }
 337
 338 void AnimatedVectorImageVisual::OnResourceReady()
 339 {
 340   // If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 341   Actor actor = mPlacementActor.GetHandle();
 342   if( actor )
 343   {
 344     actor.AddRenderer( mImpl->mRenderer );
 345     // reset the weak handle so that the renderer only get added to actor once
 346     mPlacementActor.Reset();
 347
 348     ResourceReady( Toolkit::Visual::ResourceStatus::READY );
 349   }
 350 }
 351
 352 void AnimatedVectorImageVisual::OnAnimationFinished()
 353 {
 354   if( mImpl->mEventObserver )
 355   {
 356     mImpl->mEventObserver->NotifyVisualEvent( *this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED );
 357   }
 358
 359   mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
 360
 361   if( mImpl->mRenderer )
 362   {
 363     mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 364   }
 365 }
 366
 367 void AnimatedVectorImageVisual::SendAnimationData()
 368 {
 369   if( mResendFlag )
 370   {
 371     bool isPlaying = false;
 372     if( mVectorRasterizeThread.GetPlayState() == DevelImageVisual::PlayState::PLAYING )
 373     {
 374       mVectorRasterizeThread.PauseAnimation();
 375       isPlaying = true;
 376     }
 377
 378     if( mResendFlag & RESEND_LOOP_COUNT )
 379     {
 380       mVectorRasterizeThread.SetLoopCount( mLoopCount );
 381     }
 382
 383     if( mResendFlag & RESEND_PLAY_RANGE )
 384     {
 385       mVectorRasterizeThread.SetPlayRange( mPlayRange );
 386     }
 387
 388     if( isPlaying )
 389     {
 390       mVectorRasterizeThread.PlayAnimation();
 391     }
 392     else
 393     {
 394       mVectorRasterizeThread.RenderFrame();
 395       Stage::GetCurrent().KeepRendering( 0.0f );
 396     }
 397
 398     mResendFlag = 0;
 399   }
 400 }
 401
 402 } // namespace Internal
 403
 404 } // namespace Toolkit
 405
 406 } // namespace Dali