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

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