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