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   if( mImpl->mRenderer ) // Check if we have a rendered image
 105   {
 106     auto textureSet = mImpl->mRenderer.GetTextures();
 107     if( textureSet )
 108     {
 109       if( textureSet.GetTextureCount() > 0 )
 110       {
 111         auto texture = textureSet.GetTexture( 0 );
 112         naturalSize.x = texture.GetWidth();
 113         naturalSize.y = texture.GetHeight();
 114         return;
 115       }
 116     }
 117   }
 118
 119   uint32_t width, height;
 120   mVectorRasterizeThread.GetDefaultSize( width, height );
 121   naturalSize.x = width;
 122   naturalSize.y = height;
 123 }
 124
 125 void AnimatedVectorImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 126 {
 127   map.Clear();
 128   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE );
 129   if( mUrl.IsValid() )
 130   {
 131     map.Insert( Toolkit::ImageVisual::Property::URL, mUrl.GetUrl() );
 132   }
 133   map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, mLoopCount );
 134   map.Insert( Toolkit::DevelImageVisual::Property::PLAY_RANGE, mPlayRange );
 135   map.Insert( Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast< int >( mVectorRasterizeThread.GetPlayState() ) );
 136   map.Insert( Toolkit::DevelImageVisual::Property::CURRENT_PROGRESS, mVectorRasterizeThread.GetCurrentProgress() );
 137 }
 138
 139 void AnimatedVectorImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 140 {
 141   // Do nothing
 142 }
 143
 144 void AnimatedVectorImageVisual::DoSetProperties( const Property::Map& propertyMap )
 145 {
 146   // url already passed in from constructor
 147   for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
 148   {
 149     KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
 150     if( keyValue.first.type == Property::Key::INDEX )
 151     {
 152       DoSetProperty( keyValue.first.indexKey, keyValue.second );
 153     }
 154     else
 155     {
 156        if( keyValue.first == LOOP_COUNT_NAME )
 157        {
 158           DoSetProperty( Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second );
 159        }
 160        else if( keyValue.first == PLAY_RANGE_NAME )
 161        {
 162           DoSetProperty( Toolkit::DevelImageVisual::Property::PLAY_RANGE, keyValue.second );
 163        }
 164     }
 165   }
 166 }
 167
 168 void AnimatedVectorImageVisual::DoSetProperty( Property::Index index, const Property::Value& value )
 169 {
 170   switch(index)
 171   {
 172     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
 173     {
 174       int32_t loopCount;
 175       if( value.Get( loopCount ) )
 176       {
 177         mLoopCount = loopCount;
 178         mResendFlag |= RESEND_LOOP_COUNT;
 179       }
 180       break;
 181     }
 182     case Toolkit::DevelImageVisual::Property::PLAY_RANGE:
 183     {
 184       Vector2 range;
 185       if( value.Get( range ) )
 186       {
 187         mPlayRange = range;
 188         mResendFlag |= RESEND_PLAY_RANGE;
 189       }
 190       break;
 191     }
 192   }
 193 }
 194
 195 void AnimatedVectorImageVisual::DoSetOnStage( Actor& actor )
 196 {
 197   Shader shader;
 198
 199   if( mImpl->mCustomShader )
 200   {
 201     shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource() : mImpl->mCustomShader->mVertexShader,
 202                           mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource() : mImpl->mCustomShader->mFragmentShader,
 203                           mImpl->mCustomShader->mHints );
 204
 205     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 206   }
 207   else
 208   {
 209     shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true );
 210   }
 211
 212   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 213
 214   mImpl->mRenderer = Renderer::New( geometry, shader );
 215
 216   TextureSet textureSet = TextureSet::New();
 217   mImpl->mRenderer.SetTextures( textureSet );
 218
 219   // Register transform properties
 220   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 221
 222   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 223
 224   // Hold the weak handle of the placement actor and delay the adding of renderer until the rasterization is finished.
 225   mPlacementActor = actor;
 226
 227   mVectorRasterizeThread.SetRenderer( mImpl->mRenderer );
 228 }
 229
 230 void AnimatedVectorImageVisual::DoSetOffStage( Actor& actor )
 231 {
 232   mVectorRasterizeThread.PauseAnimation();
 233
 234   mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
 235
 236   if( mImpl->mRenderer )
 237   {
 238     mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 239
 240     actor.RemoveRenderer( mImpl->mRenderer );
 241     mImpl->mRenderer.Reset();
 242   }
 243
 244   mPlacementActor.Reset();
 245
 246   // Reset the visual size to zero so that when adding the actor back to stage the rasterization is forced
 247   mVisualSize = Vector2::ZERO;
 248 }
 249
 250 void AnimatedVectorImageVisual::OnSetTransform()
 251 {
 252   Vector2 visualSize = mImpl->mTransform.GetVisualSize( mImpl->mControlSize );
 253
 254   if( IsOnStage() )
 255   {
 256     if( visualSize != mVisualSize )
 257     {
 258       mVisualSize = visualSize;
 259
 260       uint32_t width = static_cast< uint32_t >( visualSize.width );
 261       uint32_t height = static_cast< uint32_t >( visualSize.height );
 262
 263       mVectorRasterizeThread.SetSize( width, height );
 264     }
 265
 266     SendAnimationData();
 267
 268     if( mActionStatus == DevelAnimatedVectorImageVisual::Action::PLAY )
 269     {
 270       mVectorRasterizeThread.PlayAnimation();
 271
 272       mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY );
 273     }
 274     else
 275     {
 276       // Render one frame
 277       mVectorRasterizeThread.RenderFrame();
 278     }
 279
 280     if( mVectorRasterizeThread.IsResourceReady() )
 281     {
 282       Actor actor = mPlacementActor.GetHandle();
 283       if( actor )
 284       {
 285         actor.AddRenderer( mImpl->mRenderer );
 286         mPlacementActor.Reset();
 287       }
 288
 289       ResourceReady( Toolkit::Visual::ResourceStatus::READY );
 290     }
 291   }
 292 }
 293
 294 void AnimatedVectorImageVisual::OnDoAction( const Property::Index actionId, const Property::Value& attributes )
 295 {
 296   // Check if action is valid for this visual type and perform action if possible
 297   switch( actionId )
 298   {
 299     case DevelAnimatedVectorImageVisual::Action::PLAY:
 300     {
 301       if( IsOnStage() && mVisualSize != Vector2::ZERO )
 302       {
 303         mVectorRasterizeThread.PlayAnimation();
 304
 305         mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY );
 306       }
 307       mActionStatus = DevelAnimatedVectorImageVisual::Action::PLAY;
 308       break;
 309     }
 310     case DevelAnimatedVectorImageVisual::Action::PAUSE:
 311     {
 312       mVectorRasterizeThread.PauseAnimation();
 313
 314       if( mImpl->mRenderer )
 315       {
 316         mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 317       }
 318
 319       mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
 320       break;
 321     }
 322     case DevelAnimatedVectorImageVisual::Action::STOP:
 323     {
 324       if( mVectorRasterizeThread.GetPlayState() != DevelImageVisual::PlayState::STOPPED )
 325       {
 326         mVectorRasterizeThread.StopAnimation();
 327
 328         OnAnimationFinished();
 329       }
 330       mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
 331       break;
 332     }
 333     case DevelAnimatedVectorImageVisual::Action::JUMP_TO:
 334     {
 335       float progress;
 336       if( attributes.Get( progress ) )
 337       {
 338         mVectorRasterizeThread.SetCurrentProgress( progress );
 339
 340         if( mVectorRasterizeThread.GetPlayState() != DevelImageVisual::PlayState::PLAYING )
 341         {
 342           mVectorRasterizeThread.RenderFrame();
 343           Stage::GetCurrent().KeepRendering( 0.0f );    // Trigger rendering
 344         }
 345       }
 346       break;
 347     }
 348     case DevelAnimatedVectorImageVisual::Action::UPDATE_PROPERTY:
 349     {
 350       Property::Map* map = attributes.GetMap();
 351       if( map )
 352       {
 353         DoSetProperties( *map );
 354
 355         SendAnimationData();
 356       }
 357       break;
 358     }
 359   }
 360 }
 361
 362 void AnimatedVectorImageVisual::OnResourceReady()
 363 {
 364   // If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 365   Actor actor = mPlacementActor.GetHandle();
 366   if( actor )
 367   {
 368     actor.AddRenderer( mImpl->mRenderer );
 369     // reset the weak handle so that the renderer only get added to actor once
 370     mPlacementActor.Reset();
 371
 372     ResourceReady( Toolkit::Visual::ResourceStatus::READY );
 373   }
 374 }
 375
 376 void AnimatedVectorImageVisual::OnAnimationFinished()
 377 {
 378   if( mImpl->mEventObserver )
 379   {
 380     mImpl->mEventObserver->NotifyVisualEvent( *this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED );
 381   }
 382
 383   mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
 384
 385   if( mImpl->mRenderer )
 386   {
 387     mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 388   }
 389 }
 390
 391 void AnimatedVectorImageVisual::SendAnimationData()
 392 {
 393   if( mResendFlag )
 394   {
 395     bool isPlaying = false;
 396     if( mVectorRasterizeThread.GetPlayState() == DevelImageVisual::PlayState::PLAYING )
 397     {
 398       mVectorRasterizeThread.PauseAnimation();
 399       isPlaying = true;
 400     }
 401
 402     if( mResendFlag & RESEND_LOOP_COUNT )
 403     {
 404       mVectorRasterizeThread.SetLoopCount( mLoopCount );
 405     }
 406
 407     if( mResendFlag & RESEND_PLAY_RANGE )
 408     {
 409       mVectorRasterizeThread.SetPlayRange( mPlayRange );
 410     }
 411
 412     if( isPlaying )
 413     {
 414       mVectorRasterizeThread.PlayAnimation();
 415     }
 416     else
 417     {
 418       mVectorRasterizeThread.RenderFrame();
 419       Stage::GetCurrent().KeepRendering( 0.0f );
 420     }
 421
 422     mResendFlag = 0;
 423   }
 424 }
 425
 426 } // namespace Internal
 427
 428 } // namespace Toolkit
 429
 430 } // namespace Dali