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

   1 /*
   2  * Copyright (c) 2023 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/devel-api/adaptor-framework/window-devel.h>
  23 #include <dali/devel-api/common/stage.h>
  24 #include <dali/devel-api/rendering/renderer-devel.h>
  25 #include <dali/integration-api/debug.h>
  26 #include <dali/public-api/math/math-utils.h>
  27 #include <dali/public-api/rendering/decorated-visual-renderer.h>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali-toolkit/devel-api/visuals/animated-vector-image-visual-signals-devel.h>
  31 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  32 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
  33 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
  34 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  35 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  36 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  37 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  38 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  39 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  40
  41 namespace Dali
  42 {
  43 namespace Toolkit
  44 {
  45 namespace Internal
  46 {
  47 namespace
  48 {
  49 const int CUSTOM_PROPERTY_COUNT(1); // pixel area,
  50
  51 const Dali::Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  52
  53 // stop behavior
  54 DALI_ENUM_TO_STRING_TABLE_BEGIN(STOP_BEHAVIOR)
  55   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, CURRENT_FRAME)
  56   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, FIRST_FRAME)
  57   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, LAST_FRAME)
  58 DALI_ENUM_TO_STRING_TABLE_END(STOP_BEHAVIOR)
  59
  60 // looping mode
  61 DALI_ENUM_TO_STRING_TABLE_BEGIN(LOOPING_MODE)
  62   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::LoopingMode, RESTART)
  63   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::LoopingMode, AUTO_REVERSE)
  64 DALI_ENUM_TO_STRING_TABLE_END(LOOPING_MODE)
  65
  66 #if defined(DEBUG_ENABLED)
  67 Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VECTOR_ANIMATION");
  68 #endif
  69
  70 } // unnamed namespace
  71
  72 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties)
  73 {
  74   AnimatedVectorImageVisualPtr visual(new AnimatedVectorImageVisual(factoryCache, shaderFactory, imageUrl, ImageDimensions{}));
  75   visual->SetProperties(properties);
  76   visual->Initialize();
  77   return visual;
  78 }
  79
  80 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, ImageDimensions size)
  81 {
  82   AnimatedVectorImageVisualPtr visual(new AnimatedVectorImageVisual(factoryCache, shaderFactory, imageUrl, size));
  83   visual->Initialize();
  84   return visual;
  85 }
  86
  87 AnimatedVectorImageVisual::AnimatedVectorImageVisual(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, ImageDimensions size)
  88 : Visual::Base(factoryCache, Visual::FittingMode::FILL, static_cast<Toolkit::Visual::Type>(Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE)),
  89   mUrl(imageUrl),
  90   mAnimationData(),
  91   mVectorAnimationTask(new VectorAnimationTask(factoryCache)),
  92   mImageVisualShaderFactory(shaderFactory),
  93   mVisualSize(),
  94   mVisualScale(Vector2::ONE),
  95   mDesiredSize(size),
  96   mPlacementActor(),
  97   mPlayState(DevelImageVisual::PlayState::STOPPED),
  98   mEventCallback(nullptr),
  99   mLoadFailed(false),
 100   mRendererAdded(false),
 101   mCoreShutdown(false),
 102   mRedrawInScalingDown(true)
 103 {
 104   // the rasterized image is with pre-multiplied alpha format
 105   mImpl->mFlags |= Visual::Base::Impl::IS_PREMULTIPLIED_ALPHA;
 106
 107   // By default, load a file synchronously
 108   mImpl->mFlags |= Visual::Base::Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 109 }
 110
 111 AnimatedVectorImageVisual::~AnimatedVectorImageVisual()
 112 {
 113   if(!mCoreShutdown)
 114   {
 115     auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 116     vectorAnimationManager.RemoveObserver(*this);
 117
 118     if(mEventCallback)
 119     {
 120       mFactoryCache.GetVectorAnimationManager().UnregisterEventCallback(mEventCallback);
 121       mEventCallback = nullptr;
 122     }
 123
 124     // Finalize animation task and disconnect the signal in the main thread
 125     mVectorAnimationTask->ResourceReadySignal().Disconnect(this, &AnimatedVectorImageVisual::OnResourceReady);
 126     mVectorAnimationTask->Finalize();
 127   }
 128 }
 129
 130 void AnimatedVectorImageVisual::VectorAnimationManagerDestroyed()
 131 {
 132   // Core is shutting down. Don't talk to the plugin any more.
 133   mCoreShutdown = true;
 134 }
 135
 136 void AnimatedVectorImageVisual::GetNaturalSize(Vector2& naturalSize)
 137 {
 138   if(mDesiredSize.GetWidth() > 0 && mDesiredSize.GetHeight() > 0)
 139   {
 140     naturalSize.x = mDesiredSize.GetWidth();
 141     naturalSize.y = mDesiredSize.GetHeight();
 142   }
 143   else if(mVisualSize != Vector2::ZERO)
 144   {
 145     naturalSize = mVisualSize;
 146   }
 147   else
 148   {
 149     if(mLoadFailed && mImpl->mRenderer)
 150     {
 151       // Load failed, use broken image size
 152       auto textureSet = mImpl->mRenderer.GetTextures();
 153       if(textureSet && textureSet.GetTextureCount())
 154       {
 155         auto texture = textureSet.GetTexture(0);
 156         if(texture)
 157         {
 158           naturalSize.x = texture.GetWidth();
 159           naturalSize.y = texture.GetHeight();
 160           return;
 161         }
 162       }
 163     }
 164     else
 165     {
 166       uint32_t width, height;
 167       mVectorAnimationTask->GetDefaultSize(width, height);
 168       naturalSize.x = width;
 169       naturalSize.y = height;
 170     }
 171   }
 172
 173   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::GetNaturalSize: w = %f, h = %f [%p]\n", naturalSize.width, naturalSize.height, this);
 174 }
 175
 176 void AnimatedVectorImageVisual::DoCreatePropertyMap(Property::Map& map) const
 177 {
 178   map.Clear();
 179   map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE);
 180   if(mUrl.IsValid())
 181   {
 182     map.Insert(Toolkit::ImageVisual::Property::URL, mUrl.GetUrl());
 183   }
 184   map.Insert(Toolkit::DevelImageVisual::Property::LOOP_COUNT, mAnimationData.loopCount);
 185
 186   uint32_t startFrame, endFrame;
 187   mVectorAnimationTask->GetPlayRange(startFrame, endFrame);
 188
 189   Property::Array playRange;
 190   playRange.PushBack(static_cast<int32_t>(startFrame));
 191   playRange.PushBack(static_cast<int32_t>(endFrame));
 192   map.Insert(Toolkit::DevelImageVisual::Property::PLAY_RANGE, playRange);
 193
 194   map.Insert(Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast<int32_t>(mPlayState));
 195   map.Insert(Toolkit::DevelImageVisual::Property::CURRENT_FRAME_NUMBER, static_cast<int32_t>(mVectorAnimationTask->GetCurrentFrameNumber()));
 196   map.Insert(Toolkit::DevelImageVisual::Property::TOTAL_FRAME_NUMBER, static_cast<int32_t>(mVectorAnimationTask->GetTotalFrameNumber()));
 197
 198   map.Insert(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mAnimationData.stopBehavior);
 199   map.Insert(Toolkit::DevelImageVisual::Property::LOOPING_MODE, mAnimationData.loopingMode);
 200   map.Insert(Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN, mRedrawInScalingDown);
 201
 202   Property::Map layerInfo;
 203   mVectorAnimationTask->GetLayerInfo(layerInfo);
 204   map.Insert(Toolkit::DevelImageVisual::Property::CONTENT_INFO, layerInfo);
 205
 206   map.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, IsSynchronousLoadingRequired());
 207   map.Insert(Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth());
 208   map.Insert(Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight());
 209 }
 210
 211 void AnimatedVectorImageVisual::DoCreateInstancePropertyMap(Property::Map& map) const
 212 {
 213   // Do nothing
 214 }
 215
 216 void AnimatedVectorImageVisual::EnablePreMultipliedAlpha(bool preMultiplied)
 217 {
 218   // Make always enable pre multiplied alpha whether preMultiplied value is false.
 219   if(!preMultiplied)
 220   {
 221     DALI_LOG_WARNING("Note : AnimatedVectorVisual cannot disable PreMultipliedAlpha\n");
 222   }
 223 }
 224
 225 void AnimatedVectorImageVisual::DoSetProperties(const Property::Map& propertyMap)
 226 {
 227   // url already passed in from constructor
 228   for(Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter)
 229   {
 230     KeyValuePair keyValue = propertyMap.GetKeyValue(iter);
 231     if(keyValue.first.type == Property::Key::INDEX)
 232     {
 233       DoSetProperty(keyValue.first.indexKey, keyValue.second);
 234     }
 235     else
 236     {
 237       if(keyValue.first == LOOP_COUNT_NAME)
 238       {
 239         DoSetProperty(Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second);
 240       }
 241       else if(keyValue.first == PLAY_RANGE_NAME)
 242       {
 243         DoSetProperty(Toolkit::DevelImageVisual::Property::PLAY_RANGE, keyValue.second);
 244       }
 245       else if(keyValue.first == STOP_BEHAVIOR_NAME)
 246       {
 247         DoSetProperty(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second);
 248       }
 249       else if(keyValue.first == LOOPING_MODE_NAME)
 250       {
 251         DoSetProperty(Toolkit::DevelImageVisual::Property::LOOPING_MODE, keyValue.second);
 252       }
 253       else if(keyValue.first == REDRAW_IN_SCALING_DOWN_NAME)
 254       {
 255         DoSetProperty(Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN, keyValue.second);
 256       }
 257       else if(keyValue.first == SYNCHRONOUS_LOADING)
 258       {
 259         DoSetProperty(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second);
 260       }
 261       else if(keyValue.first == IMAGE_DESIRED_WIDTH)
 262       {
 263         DoSetProperty(Toolkit::ImageVisual::Property::DESIRED_WIDTH, keyValue.second);
 264       }
 265       else if(keyValue.first == IMAGE_DESIRED_HEIGHT)
 266       {
 267         DoSetProperty(Toolkit::ImageVisual::Property::DESIRED_HEIGHT, keyValue.second);
 268       }
 269     }
 270   }
 271
 272   TriggerVectorRasterization();
 273 }
 274
 275 void AnimatedVectorImageVisual::DoSetProperty(Property::Index index, const Property::Value& value)
 276 {
 277   switch(index)
 278   {
 279     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
 280     {
 281       int32_t loopCount;
 282       if(value.Get(loopCount))
 283       {
 284         mAnimationData.loopCount = loopCount;
 285         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_LOOP_COUNT;
 286       }
 287       break;
 288     }
 289     case Toolkit::DevelImageVisual::Property::PLAY_RANGE:
 290     {
 291       const Property::Array* array = value.GetArray();
 292       if(array)
 293       {
 294         mAnimationData.playRange = *array;
 295         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_RANGE;
 296       }
 297       break;
 298     }
 299     case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR:
 300     {
 301       int32_t stopBehavior = mAnimationData.stopBehavior;
 302       if(Scripting::GetEnumerationProperty(value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior))
 303       {
 304         mAnimationData.stopBehavior = DevelImageVisual::StopBehavior::Type(stopBehavior);
 305         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_STOP_BEHAVIOR;
 306       }
 307       break;
 308     }
 309     case Toolkit::DevelImageVisual::Property::LOOPING_MODE:
 310     {
 311       int32_t loopingMode = mAnimationData.loopingMode;
 312       if(Scripting::GetEnumerationProperty(value, LOOPING_MODE_TABLE, LOOPING_MODE_TABLE_COUNT, loopingMode))
 313       {
 314         mAnimationData.loopingMode = DevelImageVisual::LoopingMode::Type(loopingMode);
 315         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_LOOPING_MODE;
 316       }
 317       break;
 318     }
 319     case Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN:
 320     {
 321       bool redraw;
 322       if(value.Get(redraw))
 323       {
 324         mRedrawInScalingDown = redraw;
 325       }
 326       break;
 327     }
 328     case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING:
 329     {
 330       bool sync = false;
 331       if(value.Get(sync))
 332       {
 333         if(sync)
 334         {
 335           mImpl->mFlags |= Visual::Base::Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 336         }
 337         else
 338         {
 339           mImpl->mFlags &= ~Visual::Base::Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 340         }
 341       }
 342       break;
 343     }
 344     case Toolkit::ImageVisual::Property::DESIRED_WIDTH:
 345     {
 346       int32_t desiredWidth = 0;
 347       if(value.Get(desiredWidth))
 348       {
 349         mDesiredSize.SetWidth(desiredWidth);
 350       }
 351       break;
 352     }
 353
 354     case Toolkit::ImageVisual::Property::DESIRED_HEIGHT:
 355     {
 356       int32_t desiredHeight = 0;
 357       if(value.Get(desiredHeight))
 358       {
 359         mDesiredSize.SetHeight(desiredHeight);
 360       }
 361       break;
 362     }
 363   }
 364 }
 365
 366 void AnimatedVectorImageVisual::OnInitialize(void)
 367 {
 368   mVectorAnimationTask->ResourceReadySignal().Connect(this, &AnimatedVectorImageVisual::OnResourceReady);
 369   mVectorAnimationTask->SetAnimationFinishedCallback(new EventThreadCallback(MakeCallback(this, &AnimatedVectorImageVisual::OnAnimationFinished)));
 370
 371   mVectorAnimationTask->RequestLoad(mUrl.GetUrl(), IsSynchronousLoadingRequired());
 372
 373   auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 374   vectorAnimationManager.AddObserver(*this);
 375
 376   Shader shader = GenerateShader();
 377
 378   Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
 379
 380   mImpl->mRenderer = DecoratedVisualRenderer::New(geometry, shader);
 381   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
 382
 383   TextureSet textureSet = TextureSet::New();
 384   mImpl->mRenderer.SetTextures(textureSet);
 385
 386   // Register transform properties
 387   mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 388
 389   mVectorAnimationTask->SetRenderer(mImpl->mRenderer);
 390 }
 391
 392 void AnimatedVectorImageVisual::DoSetOnScene(Actor& actor)
 393 {
 394   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 395
 396   // Hold the weak handle of the placement actor and delay the adding of renderer until the rasterization is finished.
 397   mPlacementActor = actor;
 398
 399   if(mLoadFailed)
 400   {
 401     Vector2 imageSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
 402     mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize, false);
 403     actor.AddRenderer(mImpl->mRenderer);
 404     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 405   }
 406   else
 407   {
 408     // Add property notification for scaling & size
 409     mScaleNotification = actor.AddPropertyNotification(Actor::Property::WORLD_SCALE, StepCondition(0.1f, 1.0f));
 410     mScaleNotification.NotifySignal().Connect(this, &AnimatedVectorImageVisual::OnScaleNotification);
 411
 412     mSizeNotification = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition(3.0f));
 413     mSizeNotification.NotifySignal().Connect(this, &AnimatedVectorImageVisual::OnSizeNotification);
 414
 415     DevelActor::VisibilityChangedSignal(actor).Connect(this, &AnimatedVectorImageVisual::OnControlVisibilityChanged);
 416
 417     Window window = DevelWindow::Get(actor);
 418     if(window)
 419     {
 420       DevelWindow::VisibilityChangedSignal(window).Connect(this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged);
 421     }
 422
 423     if(mImpl->mEventObserver)
 424     {
 425       // The visual needs it's size set before it can be rasterized hence request relayout once on stage
 426       mImpl->mEventObserver->RelayoutRequest(*this);
 427     }
 428
 429     mAnimationData.resendFlag |= VectorAnimationTask::RESEND_NEED_RESOURCE_READY;
 430     TriggerVectorRasterization();
 431   }
 432
 433   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOnScene [%p]\n", this);
 434 }
 435
 436 void AnimatedVectorImageVisual::DoSetOffScene(Actor& actor)
 437 {
 438   StopAnimation();
 439   TriggerVectorRasterization();
 440
 441   if(mImpl->mRenderer)
 442   {
 443     actor.RemoveRenderer(mImpl->mRenderer);
 444     mRendererAdded = false;
 445   }
 446
 447   // Remove property notification
 448   actor.RemovePropertyNotification(mScaleNotification);
 449   actor.RemovePropertyNotification(mSizeNotification);
 450
 451   DevelActor::VisibilityChangedSignal(actor).Disconnect(this, &AnimatedVectorImageVisual::OnControlVisibilityChanged);
 452
 453   Window window = DevelWindow::Get(actor);
 454   if(window)
 455   {
 456     DevelWindow::VisibilityChangedSignal(window).Disconnect(this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged);
 457   }
 458
 459   mPlacementActor.Reset();
 460
 461   // Reset the visual size to zero so that when adding the actor back to stage the rasterization is forced
 462   mVisualSize           = Vector2::ZERO;
 463   mVisualScale          = Vector2::ONE;
 464   mAnimationData.width  = 0;
 465   mAnimationData.height = 0;
 466
 467   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOffScene [%p]\n", this);
 468 }
 469
 470 void AnimatedVectorImageVisual::OnSetTransform()
 471 {
 472   Vector2 visualSize = mImpl->mTransform.GetVisualSize(mImpl->mControlSize);
 473
 474   if(IsOnScene() && visualSize != mVisualSize)
 475   {
 476     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSetTransform: width = %f, height = %f [%p]\n", visualSize.width, visualSize.height, this);
 477
 478     mVisualSize = visualSize;
 479
 480     SetVectorImageSize();
 481
 482     if(mPlayState == DevelImageVisual::PlayState::PLAYING && mAnimationData.playState != DevelImageVisual::PlayState::PLAYING)
 483     {
 484       mAnimationData.playState = DevelImageVisual::PlayState::PLAYING;
 485       mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 486     }
 487
 488     TriggerVectorRasterization();
 489   }
 490 }
 491
 492 void AnimatedVectorImageVisual::UpdateShader()
 493 {
 494   if(mImpl->mRenderer)
 495   {
 496     Shader shader = GenerateShader();
 497     mImpl->mRenderer.SetShader(shader);
 498   }
 499 }
 500
 501 void AnimatedVectorImageVisual::OnDoAction(const Property::Index actionId, const Property::Value& attributes)
 502 {
 503   // Check if action is valid for this visual type and perform action if possible
 504   switch(actionId)
 505   {
 506     case DevelAnimatedVectorImageVisual::Action::PLAY:
 507     {
 508       if(IsOnScene() && mVisualSize != Vector2::ZERO)
 509       {
 510         if(mAnimationData.playState != DevelImageVisual::PlayState::PLAYING)
 511         {
 512           mAnimationData.playState = DevelImageVisual::PlayState::PLAYING;
 513           mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 514         }
 515       }
 516       mPlayState = DevelImageVisual::PlayState::PLAYING;
 517       break;
 518     }
 519     case DevelAnimatedVectorImageVisual::Action::PAUSE:
 520     {
 521       if(mAnimationData.playState == DevelImageVisual::PlayState::PLAYING)
 522       {
 523         mAnimationData.playState = DevelImageVisual::PlayState::PAUSED;
 524         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 525       }
 526       mPlayState = DevelImageVisual::PlayState::PAUSED;
 527       break;
 528     }
 529     case DevelAnimatedVectorImageVisual::Action::STOP:
 530     {
 531       if(mAnimationData.playState != DevelImageVisual::PlayState::STOPPED)
 532       {
 533         mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 534         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 535       }
 536       mPlayState = DevelImageVisual::PlayState::STOPPED;
 537       break;
 538     }
 539     case DevelAnimatedVectorImageVisual::Action::JUMP_TO:
 540     {
 541       int32_t frameNumber;
 542       if(attributes.Get(frameNumber))
 543       {
 544         mAnimationData.currentFrame = frameNumber;
 545         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_CURRENT_FRAME;
 546       }
 547       break;
 548     }
 549   }
 550
 551   TriggerVectorRasterization();
 552 }
 553
 554 void AnimatedVectorImageVisual::OnDoActionExtension(const Property::Index actionId, Dali::Any attributes)
 555 {
 556   switch(actionId)
 557   {
 558     case DevelAnimatedVectorImageVisual::Action::SET_DYNAMIC_PROPERTY:
 559     {
 560       DevelAnimatedVectorImageVisual::DynamicPropertyInfo info = AnyCast<DevelAnimatedVectorImageVisual::DynamicPropertyInfo>(attributes);
 561       mAnimationData.dynamicProperties.push_back(info);
 562       mAnimationData.resendFlag |= VectorAnimationTask::RESEND_DYNAMIC_PROPERTY;
 563       break;
 564     }
 565   }
 566
 567   TriggerVectorRasterization();
 568 }
 569
 570 void AnimatedVectorImageVisual::OnResourceReady(VectorAnimationTask::ResourceStatus status)
 571 {
 572   if(status == VectorAnimationTask::ResourceStatus::LOADED)
 573   {
 574     if(mImpl->mEventObserver)
 575     {
 576       mImpl->mEventObserver->RelayoutRequest(*this);
 577     }
 578   }
 579   else
 580   {
 581     mLoadFailed = status == VectorAnimationTask::ResourceStatus::FAILED ? true : false;
 582
 583     // If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 584     Actor actor = mPlacementActor.GetHandle();
 585     if(actor && !mRendererAdded)
 586     {
 587       if(!mLoadFailed)
 588       {
 589         actor.AddRenderer(mImpl->mRenderer);
 590         ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 591       }
 592       else
 593       {
 594         Vector2 imageSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
 595         mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize, false);
 596         actor.AddRenderer(mImpl->mRenderer);
 597         ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 598       }
 599
 600       mRendererAdded = true;
 601     }
 602   }
 603
 604   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "status = %d [%p]\n", status, this);
 605 }
 606
 607 void AnimatedVectorImageVisual::OnAnimationFinished()
 608 {
 609   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnAnimationFinished: action state = %d [%p]\n", mPlayState, this);
 610
 611   if(mPlayState != DevelImageVisual::PlayState::STOPPED)
 612   {
 613     mPlayState = DevelImageVisual::PlayState::STOPPED;
 614
 615     mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 616
 617     if(mImpl->mEventObserver)
 618     {
 619       mImpl->mEventObserver->NotifyVisualEvent(*this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED);
 620     }
 621   }
 622
 623   if(mImpl->mRenderer)
 624   {
 625     mImpl->mRenderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED);
 626   }
 627 }
 628
 629 void AnimatedVectorImageVisual::SendAnimationData()
 630 {
 631   if(mAnimationData.resendFlag)
 632   {
 633     mVectorAnimationTask->SetAnimationData(mAnimationData);
 634
 635     if(mImpl->mRenderer)
 636     {
 637       if(mAnimationData.playState == DevelImageVisual::PlayState::PLAYING)
 638       {
 639         mImpl->mRenderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY);
 640       }
 641       else
 642       {
 643         mImpl->mRenderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED);
 644       }
 645     }
 646
 647     mAnimationData.resendFlag = 0;
 648   }
 649 }
 650
 651 void AnimatedVectorImageVisual::SetVectorImageSize()
 652 {
 653   uint32_t width, height;
 654   if(mDesiredSize.GetWidth() > 0 && mDesiredSize.GetHeight() > 0)
 655   {
 656     width  = mDesiredSize.GetWidth();
 657     height = mDesiredSize.GetHeight();
 658   }
 659   else
 660   {
 661     width  = static_cast<uint32_t>(mVisualSize.width * mVisualScale.width);
 662     height = static_cast<uint32_t>(mVisualSize.height * mVisualScale.height);
 663   }
 664
 665   if(mAnimationData.width != width || mAnimationData.height != height)
 666   {
 667     mAnimationData.width  = width;
 668     mAnimationData.height = height;
 669     mAnimationData.resendFlag |= VectorAnimationTask::RESEND_SIZE;
 670   }
 671 }
 672
 673 void AnimatedVectorImageVisual::StopAnimation()
 674 {
 675   if(mAnimationData.playState != DevelImageVisual::PlayState::STOPPED)
 676   {
 677     mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 678     mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 679
 680     mPlayState = DevelImageVisual::PlayState::STOPPED;
 681   }
 682 }
 683
 684 void AnimatedVectorImageVisual::TriggerVectorRasterization()
 685 {
 686   if(!mEventCallback && !mCoreShutdown)
 687   {
 688     mEventCallback               = MakeCallback(this, &AnimatedVectorImageVisual::OnProcessEvents);
 689     auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 690     vectorAnimationManager.RegisterEventCallback(mEventCallback);
 691     Stage::GetCurrent().KeepRendering(0.0f); // Trigger event processing
 692   }
 693 }
 694
 695 void AnimatedVectorImageVisual::OnScaleNotification(PropertyNotification& source)
 696 {
 697   Actor actor = mPlacementActor.GetHandle();
 698   if(actor)
 699   {
 700     Vector3 scale = actor.GetProperty<Vector3>(Actor::Property::WORLD_SCALE);
 701
 702     if((!Dali::Equals(mVisualScale.width, scale.width) || !Dali::Equals(mVisualScale.height, scale.height)) && (mRedrawInScalingDown || scale.width >= 1.0f || scale.height >= 1.0f))
 703     {
 704       mVisualScale.width  = scale.width;
 705       mVisualScale.height = scale.height;
 706
 707       DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnScaleNotification: scale = %f, %f [%p]\n", mVisualScale.width, mVisualScale.height, this);
 708
 709       SetVectorImageSize();
 710       SendAnimationData();
 711
 712       Stage::GetCurrent().KeepRendering(0.0f); // Trigger event processing
 713     }
 714   }
 715 }
 716
 717 void AnimatedVectorImageVisual::OnSizeNotification(PropertyNotification& source)
 718 {
 719   Actor actor = mPlacementActor.GetHandle();
 720   if(actor)
 721   {
 722     Vector3 size = actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE);
 723
 724     if(!Dali::Equals(mVisualSize.width, size.width) || !Dali::Equals(mVisualSize.height, size.height))
 725     {
 726       mVisualSize.width  = size.width;
 727       mVisualSize.height = size.height;
 728
 729       DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSizeNotification: size = %f, %f [%p]\n", mVisualSize.width, mVisualSize.height, this);
 730
 731       SetVectorImageSize();
 732       SendAnimationData();
 733
 734       Stage::GetCurrent().KeepRendering(0.0f); // Trigger event processing
 735     }
 736   }
 737 }
 738
 739 void AnimatedVectorImageVisual::OnControlVisibilityChanged(Actor actor, bool visible, DevelActor::VisibilityChange::Type type)
 740 {
 741   if(!visible)
 742   {
 743     StopAnimation();
 744     TriggerVectorRasterization();
 745
 746     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnControlVisibilityChanged: invisibile. Pause animation [%p]\n", this);
 747   }
 748 }
 749
 750 void AnimatedVectorImageVisual::OnWindowVisibilityChanged(Window window, bool visible)
 751 {
 752   if(!visible)
 753   {
 754     StopAnimation();
 755     TriggerVectorRasterization();
 756
 757     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnWindowVisibilityChanged: invisibile. Pause animation [%p]\n", this);
 758   }
 759 }
 760
 761 void AnimatedVectorImageVisual::OnProcessEvents()
 762 {
 763   SendAnimationData();
 764
 765   mEventCallback = nullptr; // The callback will be deleted in the VectorAnimationManager
 766 }
 767
 768 Shader AnimatedVectorImageVisual::GenerateShader() const
 769 {
 770   Shader shader;
 771   if(mImpl->mCustomShader)
 772   {
 773     shader = Shader::New(mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource().data() : mImpl->mCustomShader->mVertexShader,
 774                          mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource().data() : mImpl->mCustomShader->mFragmentShader,
 775                          mImpl->mCustomShader->mHints);
 776
 777     shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
 778   }
 779   else
 780   {
 781     shader = mImageVisualShaderFactory.GetShader(
 782       mFactoryCache,
 783       ImageVisualShaderFeature::FeatureBuilder()
 784         .EnableRoundedCorner(IsRoundedCornerRequired())
 785         .EnableBorderline(IsBorderlineRequired()));
 786   }
 787   return shader;
 788 }
 789
 790 } // namespace Internal
 791
 792 } // namespace Toolkit
 793
 794 } // namespace Dali