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