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

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