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

   1 /*
   2  * Copyright (c) 2022 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/devel-api/visuals/visual-actions-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 int CUSTOM_PROPERTY_COUNT(6); // 5 transform properties + pixel area,
  48
  49 const Dali::Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  50
  51 // stop behavior
  52 DALI_ENUM_TO_STRING_TABLE_BEGIN(STOP_BEHAVIOR)
  53   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, CURRENT_FRAME)
  54   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, FIRST_FRAME)
  55   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::StopBehavior, LAST_FRAME)
  56 DALI_ENUM_TO_STRING_TABLE_END(STOP_BEHAVIOR)
  57
  58 // looping mode
  59 DALI_ENUM_TO_STRING_TABLE_BEGIN(LOOPING_MODE)
  60   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::LoopingMode, RESTART)
  61   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::Toolkit::DevelImageVisual::LoopingMode, AUTO_REVERSE)
  62 DALI_ENUM_TO_STRING_TABLE_END(LOOPING_MODE)
  63
  64 #if defined(DEBUG_ENABLED)
  65 Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VECTOR_ANIMATION");
  66 #endif
  67
  68 } // unnamed namespace
  69
  70 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties)
  71 {
  72   AnimatedVectorImageVisualPtr visual(new AnimatedVectorImageVisual(factoryCache, shaderFactory, imageUrl));
  73   visual->SetProperties(properties);
  74   visual->Initialize();
  75   return visual;
  76 }
  77
  78 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl)
  79 {
  80   AnimatedVectorImageVisualPtr visual(new AnimatedVectorImageVisual(factoryCache, shaderFactory, imageUrl));
  81   visual->Initialize();
  82   return visual;
  83 }
  84
  85 AnimatedVectorImageVisual::AnimatedVectorImageVisual(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl)
  86 : Visual::Base(factoryCache, Visual::FittingMode::FILL, static_cast<Toolkit::Visual::Type>(Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE)),
  87   mUrl(imageUrl),
  88   mAnimationData(),
  89   mVectorAnimationTask(new VectorAnimationTask(factoryCache)),
  90   mImageVisualShaderFactory(shaderFactory),
  91   mVisualSize(),
  92   mVisualScale(Vector2::ONE),
  93   mPlacementActor(),
  94   mPlayState(DevelImageVisual::PlayState::STOPPED),
  95   mEventCallback(nullptr),
  96   mLoadFailed(false),
  97   mRendererAdded(false),
  98   mCoreShutdown(false),
  99   mRedrawInScalingDown(true)
 100 {
 101   // the rasterized image is with pre-multiplied alpha format
 102   mImpl->mFlags |= Visual::Base::Impl::IS_PREMULTIPLIED_ALPHA;
 103
 104   if(!mVectorAnimationTask->Load(mUrl.GetUrl()))
 105   {
 106     mLoadFailed = true;
 107   }
 108
 109   mVectorAnimationTask->UploadCompletedSignal().Connect(this, &AnimatedVectorImageVisual::OnUploadCompleted);
 110   mVectorAnimationTask->SetAnimationFinishedCallback(new EventThreadCallback(MakeCallback(this, &AnimatedVectorImageVisual::OnAnimationFinished)));
 111
 112   auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 113   vectorAnimationManager.AddObserver(*this);
 114 }
 115
 116 AnimatedVectorImageVisual::~AnimatedVectorImageVisual()
 117 {
 118   if(!mCoreShutdown)
 119   {
 120     auto& vectorAnimationManager = mFactoryCache.GetVectorAnimationManager();
 121     vectorAnimationManager.RemoveObserver(*this);
 122
 123     if(mEventCallback)
 124     {
 125       mFactoryCache.GetVectorAnimationManager().UnregisterEventCallback(mEventCallback);
 126     }
 127
 128     // Finalize animation task and disconnect the signal in the main thread
 129     mVectorAnimationTask->UploadCompletedSignal().Disconnect(this, &AnimatedVectorImageVisual::OnUploadCompleted);
 130     mVectorAnimationTask->Finalize();
 131   }
 132 }
 133
 134 void AnimatedVectorImageVisual::VectorAnimationManagerDestroyed()
 135 {
 136   // Core is shutting down. Don't talk to the plugin any more.
 137   mCoreShutdown = true;
 138 }
 139
 140 void AnimatedVectorImageVisual::GetNaturalSize(Vector2& naturalSize)
 141 {
 142   if(mVisualSize != Vector2::ZERO)
 143   {
 144     naturalSize = mVisualSize;
 145   }
 146   else
 147   {
 148     uint32_t width, height;
 149     mVectorAnimationTask->GetDefaultSize(width, height);
 150     naturalSize.x = width;
 151     naturalSize.y = height;
 152   }
 153
 154   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::GetNaturalSize: w = %f, h = %f [%p]\n", naturalSize.width, naturalSize.height, this);
 155 }
 156
 157 void AnimatedVectorImageVisual::DoCreatePropertyMap(Property::Map& map) const
 158 {
 159   map.Clear();
 160   map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE);
 161   if(mUrl.IsValid())
 162   {
 163     map.Insert(Toolkit::ImageVisual::Property::URL, mUrl.GetUrl());
 164   }
 165   map.Insert(Toolkit::DevelImageVisual::Property::LOOP_COUNT, mAnimationData.loopCount);
 166
 167   uint32_t startFrame, endFrame;
 168   mVectorAnimationTask->GetPlayRange(startFrame, endFrame);
 169
 170   Property::Array playRange;
 171   playRange.PushBack(static_cast<int32_t>(startFrame));
 172   playRange.PushBack(static_cast<int32_t>(endFrame));
 173   map.Insert(Toolkit::DevelImageVisual::Property::PLAY_RANGE, playRange);
 174
 175   map.Insert(Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast<int32_t>(mPlayState));
 176   map.Insert(Toolkit::DevelImageVisual::Property::CURRENT_FRAME_NUMBER, static_cast<int32_t>(mVectorAnimationTask->GetCurrentFrameNumber()));
 177   map.Insert(Toolkit::DevelImageVisual::Property::TOTAL_FRAME_NUMBER, static_cast<int32_t>(mVectorAnimationTask->GetTotalFrameNumber()));
 178
 179   map.Insert(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, mAnimationData.stopBehavior);
 180   map.Insert(Toolkit::DevelImageVisual::Property::LOOPING_MODE, mAnimationData.loopingMode);
 181   map.Insert(Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN, mRedrawInScalingDown);
 182
 183   Property::Map layerInfo;
 184   mVectorAnimationTask->GetLayerInfo(layerInfo);
 185   map.Insert(Toolkit::DevelImageVisual::Property::CONTENT_INFO, layerInfo);
 186 }
 187
 188 void AnimatedVectorImageVisual::DoCreateInstancePropertyMap(Property::Map& map) const
 189 {
 190   // Do nothing
 191 }
 192
 193 void AnimatedVectorImageVisual::EnablePreMultipliedAlpha(bool preMultiplied)
 194 {
 195   // Make always enable pre multiplied alpha whether preMultiplied value is false.
 196   if(!preMultiplied)
 197   {
 198     DALI_LOG_WARNING("Note : AnimatedVectorVisual cannot disable PreMultipliedAlpha\n");
 199   }
 200 }
 201
 202 void AnimatedVectorImageVisual::DoSetProperties(const Property::Map& propertyMap)
 203 {
 204   // url already passed in from constructor
 205   for(Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter)
 206   {
 207     KeyValuePair keyValue = propertyMap.GetKeyValue(iter);
 208     if(keyValue.first.type == Property::Key::INDEX)
 209     {
 210       DoSetProperty(keyValue.first.indexKey, keyValue.second);
 211     }
 212     else
 213     {
 214       if(keyValue.first == LOOP_COUNT_NAME)
 215       {
 216         DoSetProperty(Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second);
 217       }
 218       else if(keyValue.first == PLAY_RANGE_NAME)
 219       {
 220         DoSetProperty(Toolkit::DevelImageVisual::Property::PLAY_RANGE, keyValue.second);
 221       }
 222       else if(keyValue.first == STOP_BEHAVIOR_NAME)
 223       {
 224         DoSetProperty(Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR, keyValue.second);
 225       }
 226       else if(keyValue.first == LOOPING_MODE_NAME)
 227       {
 228         DoSetProperty(Toolkit::DevelImageVisual::Property::LOOPING_MODE, keyValue.second);
 229       }
 230       else if(keyValue.first == REDRAW_IN_SCALING_DOWN_NAME)
 231       {
 232         DoSetProperty(Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN, keyValue.second);
 233       }
 234     }
 235   }
 236
 237   TriggerVectorRasterization();
 238 }
 239
 240 void AnimatedVectorImageVisual::DoSetProperty(Property::Index index, const Property::Value& value)
 241 {
 242   switch(index)
 243   {
 244     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
 245     {
 246       int32_t loopCount;
 247       if(value.Get(loopCount))
 248       {
 249         mAnimationData.loopCount = loopCount;
 250         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_LOOP_COUNT;
 251       }
 252       break;
 253     }
 254     case Toolkit::DevelImageVisual::Property::PLAY_RANGE:
 255     {
 256       const Property::Array* array = value.GetArray();
 257       if(array)
 258       {
 259         mAnimationData.playRange = *array;
 260         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_RANGE;
 261       }
 262       break;
 263     }
 264     case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR:
 265     {
 266       int32_t stopBehavior = mAnimationData.stopBehavior;
 267       if(Scripting::GetEnumerationProperty(value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior))
 268       {
 269         mAnimationData.stopBehavior = DevelImageVisual::StopBehavior::Type(stopBehavior);
 270         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_STOP_BEHAVIOR;
 271       }
 272       break;
 273     }
 274     case Toolkit::DevelImageVisual::Property::LOOPING_MODE:
 275     {
 276       int32_t loopingMode = mAnimationData.loopingMode;
 277       if(Scripting::GetEnumerationProperty(value, LOOPING_MODE_TABLE, LOOPING_MODE_TABLE_COUNT, loopingMode))
 278       {
 279         mAnimationData.loopingMode = DevelImageVisual::LoopingMode::Type(loopingMode);
 280         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_LOOPING_MODE;
 281       }
 282       break;
 283     }
 284     case Toolkit::DevelImageVisual::Property::REDRAW_IN_SCALING_DOWN:
 285     {
 286       bool redraw;
 287       if(value.Get(redraw))
 288       {
 289         mRedrawInScalingDown = redraw;
 290       }
 291       break;
 292     }
 293   }
 294 }
 295
 296 void AnimatedVectorImageVisual::OnInitialize(void)
 297 {
 298   Shader shader = GenerateShader();
 299
 300   Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
 301
 302   mImpl->mRenderer = VisualRenderer::New(geometry, shader);
 303   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
 304
 305   TextureSet textureSet = TextureSet::New();
 306   mImpl->mRenderer.SetTextures(textureSet);
 307
 308   // Register transform properties
 309   mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 310 }
 311
 312 void AnimatedVectorImageVisual::DoSetOnScene(Actor& actor)
 313 {
 314   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 315
 316   // Hold the weak handle of the placement actor and delay the adding of renderer until the rasterization is finished.
 317   mPlacementActor = actor;
 318
 319   if(mLoadFailed)
 320   {
 321     Vector2 imageSize = Vector2::ZERO;
 322     imageSize         = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
 323     mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize);
 324     actor.AddRenderer(mImpl->mRenderer);
 325     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 326   }
 327   else
 328   {
 329     mVectorAnimationTask->SetRenderer(mImpl->mRenderer);
 330
 331     // Add property notification for scaling & size
 332     mScaleNotification = actor.AddPropertyNotification(Actor::Property::WORLD_SCALE, StepCondition(0.1f, 1.0f));
 333     mScaleNotification.NotifySignal().Connect(this, &AnimatedVectorImageVisual::OnScaleNotification);
 334
 335     mSizeNotification = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition(3.0f));
 336     mSizeNotification.NotifySignal().Connect(this, &AnimatedVectorImageVisual::OnSizeNotification);
 337
 338     DevelActor::VisibilityChangedSignal(actor).Connect(this, &AnimatedVectorImageVisual::OnControlVisibilityChanged);
 339
 340     Window window = DevelWindow::Get(actor);
 341     if(window)
 342     {
 343       DevelWindow::VisibilityChangedSignal(window).Connect(this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged);
 344     }
 345   }
 346
 347   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOnScene [%p]\n", this);
 348 }
 349
 350 void AnimatedVectorImageVisual::DoSetOffScene(Actor& actor)
 351 {
 352   StopAnimation();
 353   SendAnimationData();
 354
 355   if(mImpl->mRenderer)
 356   {
 357     actor.RemoveRenderer(mImpl->mRenderer);
 358     mRendererAdded = false;
 359   }
 360
 361   // Remove property notification
 362   actor.RemovePropertyNotification(mScaleNotification);
 363   actor.RemovePropertyNotification(mSizeNotification);
 364
 365   DevelActor::VisibilityChangedSignal(actor).Disconnect(this, &AnimatedVectorImageVisual::OnControlVisibilityChanged);
 366
 367   Window window = DevelWindow::Get(actor);
 368   if(window)
 369   {
 370     DevelWindow::VisibilityChangedSignal(window).Disconnect(this, &AnimatedVectorImageVisual::OnWindowVisibilityChanged);
 371   }
 372
 373   mPlacementActor.Reset();
 374
 375   // Reset the visual size to zero so that when adding the actor back to stage the rasterization is forced
 376   mVisualSize  = Vector2::ZERO;
 377   mVisualScale = Vector2::ONE;
 378
 379   DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::DoSetOffScene [%p]\n", this);
 380 }
 381
 382 void AnimatedVectorImageVisual::OnSetTransform()
 383 {
 384   Vector2 visualSize = mImpl->mTransform.GetVisualSize(mImpl->mControlSize);
 385
 386   if(IsOnScene() && visualSize != mVisualSize)
 387   {
 388     DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnSetTransform: width = %f, height = %f [%p]\n", visualSize.width, visualSize.height, this);
 389
 390     mVisualSize = visualSize;
 391
 392     SetVectorImageSize();
 393
 394     if(mPlayState == DevelImageVisual::PlayState::PLAYING && mAnimationData.playState != DevelImageVisual::PlayState::PLAYING)
 395     {
 396       mAnimationData.playState = DevelImageVisual::PlayState::PLAYING;
 397       mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 398     }
 399
 400     SendAnimationData();
 401   }
 402 }
 403
 404 void AnimatedVectorImageVisual::UpdateShader()
 405 {
 406   if(mImpl->mRenderer)
 407   {
 408     Shader shader = GenerateShader();
 409     mImpl->mRenderer.SetShader(shader);
 410   }
 411 }
 412
 413 void AnimatedVectorImageVisual::OnDoAction(const Property::Index actionId, const Property::Value& attributes)
 414 {
 415   // Check if action is valid for this visual type and perform action if possible
 416   switch(actionId)
 417   {
 418     case DevelAnimatedVectorImageVisual::Action::PLAY:
 419     {
 420       if(IsOnScene() && mVisualSize != Vector2::ZERO)
 421       {
 422         if(mAnimationData.playState != DevelImageVisual::PlayState::PLAYING)
 423         {
 424           mAnimationData.playState = DevelImageVisual::PlayState::PLAYING;
 425           mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 426         }
 427       }
 428       mPlayState = DevelImageVisual::PlayState::PLAYING;
 429       break;
 430     }
 431     case DevelAnimatedVectorImageVisual::Action::PAUSE:
 432     {
 433       if(mAnimationData.playState == DevelImageVisual::PlayState::PLAYING)
 434       {
 435         mAnimationData.playState = DevelImageVisual::PlayState::PAUSED;
 436         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 437       }
 438       mPlayState = DevelImageVisual::PlayState::PAUSED;
 439       break;
 440     }
 441     case DevelAnimatedVectorImageVisual::Action::STOP:
 442     {
 443       if(mAnimationData.playState != DevelImageVisual::PlayState::STOPPED)
 444       {
 445         mAnimationData.playState = DevelImageVisual::PlayState::STOPPED;
 446         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_PLAY_STATE;
 447       }
 448       mPlayState = DevelImageVisual::PlayState::STOPPED;
 449       break;
 450     }
 451     case DevelAnimatedVectorImageVisual::Action::JUMP_TO:
 452     {
 453       int32_t frameNumber;
 454       if(attributes.Get(frameNumber))
 455       {
 456         mAnimationData.currentFrame = frameNumber;
 457         mAnimationData.resendFlag |= VectorAnimationTask::RESEND_CURRENT_FRAME;
 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       ImageVisualShaderFeature::FeatureBuilder()
 642         .EnableRoundedCorner(IsRoundedCornerRequired())
 643         .EnableBorderline(IsBorderlineRequired()));
 644   }
 645   return shader;
 646 }
 647
 648 } // namespace Internal
 649
 650 } // namespace Toolkit
 651
 652 } // namespace Dali