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     TextureSet textureSet = TextureSet::New();
 309     mImpl->mRenderer.SetTextures(textureSet);
 310
 311     Texture brokenImage = mFactoryCache.GetBrokenVisualImage();
 312     textureSet.SetTexture(0u, brokenImage);
 313
 314     actor.AddRenderer(mImpl->mRenderer);
 315
 316     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 317   }
 318   else
 319   {
 320     mVectorAnimationTask->SetRenderer(mImpl->mRenderer);
 321
 322     // Add property notification for scaling & size
 323     mScaleNotification = actor.AddPropertyNotification(Actor::Property::WORLD_SCALE, StepCondition(0.1f, 1.0f));
 324     mScaleNotification.NotifySignal().Connect(this, &AnimatedVectorImageVisual::OnScaleNotification);
 325
 326     mSizeNotification = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition(3.0f));
 327     mSizeNotification.NotifySignal().Connect(this, &AnimatedVectorImageVisual::OnSizeNotification);
 328
 329     DevelActor::VisibilityChangedSignal(actor).Connect(this, &AnimatedVectorImageVisual::OnControlVisibilityChanged);
 330
 331     Window window = DevelWindow::Get(actor);
 332     if(window)
 333     {
 334       DevelWindow::VisibilityChangedSignal(window).Connect(this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged);
 335     }
 336   }
 337
 338   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOnScene [%p]\n", this);
 339 }
 340
 341 void AnimatedVectorImageVisual::DoSetOffScene(Actor& actor)
 342 {
 343   StopAnimation();
 344   SendAnimationData();
 345
 346   if(mImpl->mRenderer)
 347   {
 348     actor.RemoveRenderer(mImpl->mRenderer);
 349     mRendererAdded = false;
 350   }
 351
 352   // Remove property notification
 353   actor.RemovePropertyNotification(mScaleNotification);
 354   actor.RemovePropertyNotification(mSizeNotification);
 355
 356   DevelActor::VisibilityChangedSignal(actor).Disconnect(this, &AnimatedVectorImageVisual::OnControlVisibilityChanged);
 357
 358   Window window = DevelWindow::Get(actor);
 359   if(window)
 360   {
 361     DevelWindow::VisibilityChangedSignal(window).Disconnect(this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged);
 362   }
 363
 364   mPlacementActor.Reset();
 365
 366   // Reset the visual size to zero so that when adding the actor back to stage the rasterization is forced
 367   mVisualSize  = Vector2::ZERO;
 368   mVisualScale = Vector2::ONE;
 369
 370   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOffScene [%p]\n", this);
 371 }
 372
 373 void AnimatedVectorImageVisual::OnSetTransform()
 374 {
 375   Vector2 visualSize = mImpl->mTransform.GetVisualSize(mImpl->mControlSize);
 376
 377   if(IsOnScene() && visualSize != mVisualSize)
 378   {
 379     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSetTransform: width = %f, height = %f [%p]\n", visualSize.width, visualSize.height, this);
 380
 381     mVisualSize = visualSize;
 382
 383     SetVectorImageSize();
 384
 385     if(mPlayState == DevelImageVisual::PlayState::PLAYING && mAnimationData.playState != DevelImageVisual::PlayState::PLAYING)
 386     {
 387       mAnimationData.playState = DevelImageVisual::PlayState::PLAYING;
 388       mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 389     }
 390
 391     SendAnimationData();
 392   }
 393 }
 394
 395 void AnimatedVectorImageVisual::UpdateShader()
 396 {
 397   if(mImpl->mRenderer)
 398   {
 399     Shader shader = GenerateShader();
 400     mImpl->mRenderer.SetShader(shader);
 401   }
 402 }
 403
 404 void AnimatedVectorImageVisual::OnDoAction(const Property::Index actionId, const Property::Value& attributes)
 405 {
 406   // Check if action is valid for this visual type and perform action if possible
 407   switch(actionId)
 408   {
 409     case DevelAnimatedVectorImageVisual::Action::PLAY:
 410     {
 411       if(IsOnScene() && mVisualSize != Vector2::ZERO)
 412       {
 413         if(mAnimationData.playState != DevelImageVisual::PlayState::PLAYING)
 414         {
 415           mAnimationData.playState = DevelImageVisual::PlayState::PLAYING;
 416           mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 417         }
 418       }
 419       mPlayState = DevelImageVisual::PlayState::PLAYING;
 420       break;
 421     }
 422     case DevelAnimatedVectorImageVisual::Action::PAUSE:
 423     {
 424       if(mAnimationData.playState == DevelImageVisual::PlayState::PLAYING)
 425       {
 426         mAnimationData.playState = DevelImageVisual::PlayState::PAUSED;
 427         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 428       }
 429       mPlayState = DevelImageVisual::PlayState::PAUSED;
 430       break;
 431     }
 432     case DevelAnimatedVectorImageVisual::Action::STOP:
 433     {
 434       if(mAnimationData.playState != DevelImageVisual::PlayState::STOPPED)
 435       {
 436         mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 437         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 438       }
 439       mPlayState = DevelImageVisual::PlayState::STOPPED;
 440       break;
 441     }
 442     case DevelAnimatedVectorImageVisual::Action::JUMP_TO:
 443     {
 444       int32_t frameNumber;
 445       if(attributes.Get(frameNumber))
 446       {
 447         mAnimationData.currentFrame = frameNumber;
 448         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_CURRENT_FRAME;
 449       }
 450       break;
 451     }
 452     case DevelAnimatedVectorImageVisual::Action::UPDATE_PROPERTY:
 453     {
 454       const Property::Map* map = attributes.GetMap();
 455       if(map)
 456       {
 457         DoSetProperties(*map);
 458       }
 459       break;
 460     }
 461   }
 462
 463   TriggerVectorRasterization();
 464 }
 465
 466 void AnimatedVectorImageVisual::OnUploadCompleted()
 467 {
 468   // If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 469   Actor actor = mPlacementActor.GetHandle();
 470   if(actor && !mRendererAdded)
 471   {
 472     actor.AddRenderer(mImpl->mRenderer);
 473     mRendererAdded = true;
 474
 475     ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 476
 477     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnUploadCompleted: Renderer is added [%p]\n", this);
 478   }
 479 }
 480
 481 void AnimatedVectorImageVisual::OnAnimationFinished()
 482 {
 483   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnAnimationFinished: action state = %d [%p]\n", mPlayState, this);
 484
 485   if(mPlayState != DevelImageVisual::PlayState::STOPPED)
 486   {
 487     mPlayState = DevelImageVisual::PlayState::STOPPED;
 488
 489     mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 490
 491     if(mImpl->mEventObserver)
 492     {
 493       mImpl->mEventObserver->NotifyVisualEvent(*this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED);
 494     }
 495   }
 496
 497   if(mImpl->mRenderer)
 498   {
 499     mImpl->mRenderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED);
 500   }
 501 }
 502
 503 void AnimatedVectorImageVisual::SendAnimationData()
 504 {
 505   if(mAnimationData.resendFlag)
 506   {
 507     mVectorAnimationTask->SetAnimationData(mAnimationData);
 508
 509     if(mImpl->mRenderer)
 510     {
 511       if(mAnimationData.playState == DevelImageVisual::PlayState::PLAYING)
 512       {
 513         mImpl->mRenderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY);
 514       }
 515       else
 516       {
 517         mImpl->mRenderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED);
 518       }
 519     }
 520
 521     mAnimationData.resendFlag = 0;
 522   }
 523 }
 524
 525 void AnimatedVectorImageVisual::SetVectorImageSize()
 526 {
 527   uint32_t width  = static_cast<uint32_t>(mVisualSize.width * mVisualScale.width);
 528   uint32_t height = static_cast<uint32_t>(mVisualSize.height * mVisualScale.height);
 529
 530   mAnimationData.width  = width;
 531   mAnimationData.height = height;
 532   mAnimationData.resendFlag |= VectorAnimationTask::RESEND_SIZE;
 533 }
 534
 535 void AnimatedVectorImageVisual::StopAnimation()
 536 {
 537   if(mAnimationData.playState != DevelImageVisual::PlayState::STOPPED)
 538   {
 539     mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 540     mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 541
 542     mPlayState = DevelImageVisual::PlayState::STOPPED;
 543   }
 544 }
 545
 546 void AnimatedVectorImageVisual::TriggerVectorRasterization()
 547 {
 548   if(!mEventCallback && !mCoreShutdown)
 549   {
 550     mEventCallback               = MakeCallback(this, &AnimatedVectorImageVisual::OnProcessEvents);
 551     auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 552     vectorAnimationManager.RegisterEventCallback(mEventCallback);
 553     Stage::GetCurrent().KeepRendering(0.0f); // Trigger event processing
 554   }
 555 }
 556
 557 void AnimatedVectorImageVisual::OnScaleNotification(PropertyNotification& source)
 558 {
 559   Actor actor = mPlacementActor.GetHandle();
 560   if(actor)
 561   {
 562     Vector3 scale = actor.GetProperty<Vector3>(Actor::Property::WORLD_SCALE);
 563
 564     if(mRedrawInScalingDown || scale.width >= 1.0f || scale.height >= 1.0f)
 565     {
 566       mVisualScale.width  = scale.width;
 567       mVisualScale.height = scale.height;
 568
 569       DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnScaleNotification: scale = %f, %f [%p]\n", mVisualScale.width, mVisualScale.height, this);
 570
 571       SetVectorImageSize();
 572       SendAnimationData();
 573
 574       Stage::GetCurrent().KeepRendering(0.0f); // Trigger event processing
 575     }
 576   }
 577 }
 578
 579 void AnimatedVectorImageVisual::OnSizeNotification(PropertyNotification& source)
 580 {
 581   Actor actor = mPlacementActor.GetHandle();
 582   if(actor)
 583   {
 584     Vector3 size       = actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE);
 585     mVisualSize.width  = size.width;
 586     mVisualSize.height = size.height;
 587
 588     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSizeNotification: size = %f, %f [%p]\n", mVisualSize.width, mVisualSize.height, this);
 589
 590     SetVectorImageSize();
 591     SendAnimationData();
 592
 593     Stage::GetCurrent().KeepRendering(0.0f); // Trigger event processing
 594   }
 595 }
 596
 597 void AnimatedVectorImageVisual::OnControlVisibilityChanged(Actor actor, bool visible, DevelActor::VisibilityChange::Type type)
 598 {
 599   if(!visible)
 600   {
 601     StopAnimation();
 602     TriggerVectorRasterization();
 603
 604     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnControlVisibilityChanged: invisibile. Pause animation [%p]\n", this);
 605   }
 606 }
 607
 608 void AnimatedVectorImageVisual::OnWindowVisibilityChanged(Window window, bool visible)
 609 {
 610   if(!visible)
 611   {
 612     StopAnimation();
 613     TriggerVectorRasterization();
 614
 615     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnWindowVisibilityChanged: invisibile. Pause animation [%p]\n", this);
 616   }
 617 }
 618
 619 void AnimatedVectorImageVisual::OnProcessEvents()
 620 {
 621   SendAnimationData();
 622
 623   mEventCallback = nullptr; // The callback will be deleted in the VectorAnimationManager
 624 }
 625
 626 Shader AnimatedVectorImageVisual::GenerateShader() const
 627 {
 628   Shader shader;
 629   if(mImpl->mCustomShader)
 630   {
 631     shader = Shader::New(mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource().data() : mImpl->mCustomShader->mVertexShader,
 632                          mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource().data() : mImpl->mCustomShader->mFragmentShader,
 633                          mImpl->mCustomShader->mHints);
 634
 635     shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
 636   }
 637   else
 638   {
 639     shader = mImageVisualShaderFactory.GetShader(
 640       mFactoryCache,
 641       TextureAtlas::DISABLED,
 642       DefaultTextureWrapMode::APPLY,
 643       IsRoundedCornerRequired() ? RoundedCorner::ENABLED : RoundedCorner::DISABLED,
 644       IsBorderlineRequired() ? Borderline::ENABLED : Borderline::DISABLED
 645     );
 646   }
 647   return shader;
 648 }
 649
 650
 651 } // namespace Internal
 652
 653 } // namespace Toolkit
 654
 655 } // namespace Dali