dali-toolkit/internal/visuals/svg/svg-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/svg/svg-visual.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
  23 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  24 #include <dali-toolkit/internal/visuals/image-visual-shader-feature-builder.h>
  25 #include <dali-toolkit/internal/visuals/svg/svg-task.h>
  26 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  27 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  28 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  29
  30 // EXTERNAL INCLUDES
  31 #include <dali/devel-api/common/stage.h>
  32 #include <dali/integration-api/debug.h>
  33 #include <dali/public-api/rendering/decorated-visual-renderer.h>
  34
  35 namespace Dali
  36 {
  37 namespace Toolkit
  38 {
  39 namespace Internal
  40 {
  41 namespace
  42 {
  43 const int CUSTOM_PROPERTY_COUNT(1); // atlas
  44
  45 // property name
  46 const Dali::Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  47
  48 } // namespace
  49
  50 SvgVisualPtr SvgVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties)
  51 {
  52   SvgVisualPtr svgVisual(new SvgVisual(factoryCache, shaderFactory, imageUrl, ImageDimensions{}));
  53   svgVisual->SetProperties(properties);
  54   svgVisual->Initialize();
  55   return svgVisual;
  56 }
  57
  58 SvgVisualPtr SvgVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, ImageDimensions size)
  59 {
  60   SvgVisualPtr svgVisual(new SvgVisual(factoryCache, shaderFactory, imageUrl, size));
  61   svgVisual->Initialize();
  62   return svgVisual;
  63 }
  64
  65 SvgVisual::SvgVisual(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, ImageDimensions size)
  66 : Visual::Base(factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::SVG),
  67   mImageVisualShaderFactory(shaderFactory),
  68   mAtlasRect(FULL_TEXTURE_RECT),
  69   mImageUrl(imageUrl),
  70   mVectorRenderer(VectorImageRenderer::New()),
  71   mDefaultWidth(0),
  72   mDefaultHeight(0),
  73   mPlacementActor(),
  74   mRasterizedSize(-Vector2::ONE), ///< Let we don't use zero since visual size could be zero after trasnform
  75   mDesiredSize(size),
  76   mLoadFailed(false),
  77   mAttemptAtlasing(false)
  78 {
  79   // the rasterized image is with pre-multiplied alpha format
  80   mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA;
  81 }
  82
  83 SvgVisual::~SvgVisual()
  84 {
  85   if(Stage::IsInstalled())
  86   {
  87     if(mLoadingTask)
  88     {
  89       Dali::AsyncTaskManager::Get().RemoveTask(mLoadingTask);
  90     }
  91     if(mRasterizingTask)
  92     {
  93       Dali::AsyncTaskManager::Get().RemoveTask(mRasterizingTask);
  94     }
  95
  96     if(mImageUrl.IsBufferResource())
  97     {
  98       TextureManager& textureManager = mFactoryCache.GetTextureManager();
  99       textureManager.RemoveEncodedImageBuffer(mImageUrl.GetUrl());
 100     }
 101   }
 102 }
 103
 104 void SvgVisual::OnInitialize()
 105 {
 106   Shader   shader   = GenerateShader();
 107   Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
 108   mImpl->mRenderer  = DecoratedVisualRenderer::New(geometry, shader);
 109   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
 110
 111   Vector2 dpi     = Stage::GetCurrent().GetDpi();
 112   float   meanDpi = (dpi.height + dpi.width) * 0.5f;
 113
 114   EncodedImageBuffer encodedImageBuffer;
 115
 116   if(mImageUrl.IsBufferResource())
 117   {
 118     // Increase reference count of External Resources :
 119     // EncodedImageBuffer.
 120     // Reference count will be decreased at destructor of the visual.
 121     TextureManager& textureManager = mFactoryCache.GetTextureManager();
 122     textureManager.UseExternalResource(mImageUrl.GetUrl());
 123
 124     encodedImageBuffer = textureManager.GetEncodedImageBuffer(mImageUrl.GetUrl());
 125   }
 126
 127   mLoadingTask = new SvgLoadingTask(mVectorRenderer, mImageUrl, encodedImageBuffer, meanDpi, MakeCallback(this, &SvgVisual::ApplyRasterizedImage));
 128
 129   if(IsSynchronousLoadingRequired() && (mImageUrl.IsLocalResource() || mImageUrl.IsBufferResource()))
 130   {
 131     mLoadingTask->Process();
 132     if(!mLoadingTask->HasSucceeded())
 133     {
 134       mLoadFailed = true;
 135     }
 136     mLoadingTask.Reset(); // We don't need it anymore.
 137   }
 138   else
 139   {
 140     Dali::AsyncTaskManager::Get().AddTask(mLoadingTask);
 141   }
 142 }
 143
 144 void SvgVisual::DoSetProperties(const Property::Map& propertyMap)
 145 {
 146   // url already passed in from constructor
 147   for(Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter)
 148   {
 149     KeyValuePair keyValue = propertyMap.GetKeyValue(iter);
 150     if(keyValue.first.type == Property::Key::INDEX)
 151     {
 152       DoSetProperty(keyValue.first.indexKey, keyValue.second);
 153     }
 154     else if(keyValue.first == IMAGE_ATLASING)
 155     {
 156       DoSetProperty(Toolkit::ImageVisual::Property::ATLASING, keyValue.second);
 157     }
 158     else if(keyValue.first == SYNCHRONOUS_LOADING)
 159     {
 160       DoSetProperty(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second);
 161     }
 162     else if(keyValue.first == IMAGE_DESIRED_WIDTH)
 163     {
 164       DoSetProperty(Toolkit::ImageVisual::Property::DESIRED_WIDTH, keyValue.second);
 165     }
 166     else if(keyValue.first == IMAGE_DESIRED_HEIGHT)
 167     {
 168       DoSetProperty(Toolkit::ImageVisual::Property::DESIRED_HEIGHT, keyValue.second);
 169     }
 170   }
 171 }
 172
 173 void SvgVisual::DoSetProperty(Property::Index index, const Property::Value& value)
 174 {
 175   switch(index)
 176   {
 177     case Toolkit::ImageVisual::Property::ATLASING:
 178     {
 179       value.Get(mAttemptAtlasing);
 180       break;
 181     }
 182     case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING:
 183     {
 184       bool sync = false;
 185       if(value.Get(sync))
 186       {
 187         if(sync)
 188         {
 189           mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 190         }
 191         else
 192         {
 193           mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 194         }
 195       }
 196       else
 197       {
 198         DALI_LOG_ERROR("ImageVisual: synchronousLoading property has incorrect type\n");
 199       }
 200       break;
 201     }
 202     case Toolkit::ImageVisual::Property::DESIRED_WIDTH:
 203     {
 204       int32_t desiredWidth = 0;
 205       if(value.Get(desiredWidth))
 206       {
 207         mDesiredSize.SetWidth(desiredWidth);
 208       }
 209       break;
 210     }
 211     case Toolkit::ImageVisual::Property::DESIRED_HEIGHT:
 212     {
 213       int32_t desiredHeight = 0;
 214       if(value.Get(desiredHeight))
 215       {
 216         mDesiredSize.SetHeight(desiredHeight);
 217       }
 218       break;
 219     }
 220   }
 221 }
 222
 223 void SvgVisual::DoSetOnScene(Actor& actor)
 224 {
 225   TextureSet textureSet = TextureSet::New();
 226   mImpl->mRenderer.SetTextures(textureSet);
 227
 228   // Register transform properties
 229   mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 230
 231   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 232
 233   // Hold the weak handle of the placement actor and delay the adding of renderer until the svg rasterization is finished.
 234   mPlacementActor = actor;
 235
 236   if(mLoadFailed)
 237   {
 238     Vector2 imageSize = Vector2::ZERO;
 239     imageSize         = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
 240     mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize);
 241     actor.AddRenderer(mImpl->mRenderer);
 242
 243     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 244   }
 245   else
 246   {
 247     if(mImpl->mEventObserver)
 248     {
 249       // SVG visual needs it's size set before it can be rasterized hence request relayout once on stage
 250       mImpl->mEventObserver->RelayoutRequest(*this);
 251     }
 252   }
 253 }
 254
 255 void SvgVisual::DoSetOffScene(Actor& actor)
 256 {
 257   // Remove rasterizing task
 258   if(mRasterizingTask)
 259   {
 260     Dali::AsyncTaskManager::Get().RemoveTask(mRasterizingTask);
 261     mRasterizingTask.Reset();
 262   }
 263
 264   actor.RemoveRenderer(mImpl->mRenderer);
 265   mPlacementActor.Reset();
 266
 267   // Reset the visual size to zero so that when adding the actor back to stage the SVG rasterization is forced
 268   mRasterizedSize = Vector2::ZERO;
 269 }
 270
 271 void SvgVisual::GetNaturalSize(Vector2& naturalSize)
 272 {
 273   if(mDesiredSize.GetWidth() > 0 && mDesiredSize.GetHeight() > 0)
 274   {
 275     naturalSize.x = mDesiredSize.GetWidth();
 276     naturalSize.y = mDesiredSize.GetHeight();
 277   }
 278   else if(mLoadFailed && mImpl->mRenderer)
 279   {
 280     // Load failed, use broken image size
 281     auto textureSet = mImpl->mRenderer.GetTextures();
 282     if(textureSet && textureSet.GetTextureCount())
 283     {
 284       auto texture = textureSet.GetTexture(0);
 285       if(texture)
 286       {
 287         naturalSize.x = texture.GetWidth();
 288         naturalSize.y = texture.GetHeight();
 289         return;
 290       }
 291     }
 292   }
 293   else
 294   {
 295     naturalSize.x = mDefaultWidth;
 296     naturalSize.y = mDefaultHeight;
 297   }
 298 }
 299
 300 void SvgVisual::DoCreatePropertyMap(Property::Map& map) const
 301 {
 302   map.Clear();
 303   map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::SVG);
 304   if(mImageUrl.IsValid())
 305   {
 306     map.Insert(Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl());
 307     map.Insert(Toolkit::ImageVisual::Property::ATLASING, mAttemptAtlasing);
 308   }
 309   map.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, IsSynchronousLoadingRequired());
 310   map.Insert(Toolkit::ImageVisual::Property::DESIRED_WIDTH, mDesiredSize.GetWidth());
 311   map.Insert(Toolkit::ImageVisual::Property::DESIRED_HEIGHT, mDesiredSize.GetHeight());
 312 }
 313
 314 void SvgVisual::DoCreateInstancePropertyMap(Property::Map& map) const
 315 {
 316   // Do nothing
 317 }
 318
 319 void SvgVisual::EnablePreMultipliedAlpha(bool preMultiplied)
 320 {
 321   // Make always enable pre multiplied alpha whether preMultiplied value is false.
 322   if(!preMultiplied)
 323   {
 324     DALI_LOG_WARNING("Note : SvgVisual cannot disable PreMultipliedAlpha\n");
 325   }
 326 }
 327
 328 void SvgVisual::AddRasterizationTask(const Vector2& size)
 329 {
 330   if(mImpl->mRenderer)
 331   {
 332     // Remove previous task
 333     if(mRasterizingTask)
 334     {
 335       Dali::AsyncTaskManager::Get().RemoveTask(mRasterizingTask);
 336       mRasterizingTask.Reset();
 337     }
 338
 339     unsigned int width  = static_cast<unsigned int>(size.width);
 340     unsigned int height = static_cast<unsigned int>(size.height);
 341
 342     mRasterizingTask = new SvgRasterizingTask(mVectorRenderer, width, height, MakeCallback(this, &SvgVisual::ApplyRasterizedImage));
 343
 344 #ifdef TRACE_ENABLED
 345     reinterpret_cast<SvgRasterizingTask*>(mRasterizingTask.Get())->SetUrl(mImageUrl);
 346 #endif
 347
 348     if(IsSynchronousLoadingRequired() && mImageUrl.IsLocalResource())
 349     {
 350       mRasterizingTask->Process();
 351       ApplyRasterizedImage(mRasterizingTask);
 352       mRasterizingTask.Reset(); // We don't need it anymore.
 353     }
 354     else
 355     {
 356       Dali::AsyncTaskManager::Get().AddTask(mRasterizingTask);
 357     }
 358   }
 359 }
 360
 361 void SvgVisual::ApplyRasterizedImage(SvgTaskPtr task)
 362 {
 363   SvgVisualPtr self = this; // Keep reference until this API finished
 364
 365   if(task->HasSucceeded())
 366   {
 367     PixelData rasterizedPixelData = task->GetPixelData();
 368     if(mDefaultWidth == 0 || mDefaultHeight == 0)
 369     {
 370       task->GetRenderer().GetDefaultSize(mDefaultWidth, mDefaultHeight);
 371     }
 372
 373     // We don't need to keep tasks anymore. reset now.
 374     if(task == mLoadingTask)
 375     {
 376       mLoadingTask.Reset();
 377     }
 378     if(task == mRasterizingTask)
 379     {
 380       mRasterizingTask.Reset();
 381     }
 382
 383     // Rasterization success
 384     if(rasterizedPixelData && IsOnScene())
 385     {
 386       mRasterizedSize.x = static_cast<float>(rasterizedPixelData.GetWidth());
 387       mRasterizedSize.y = static_cast<float>(rasterizedPixelData.GetHeight());
 388
 389       TextureSet currentTextureSet = mImpl->mRenderer.GetTextures();
 390       if(mImpl->mFlags & Impl::IS_ATLASING_APPLIED)
 391       {
 392         mFactoryCache.GetAtlasManager()->Remove(currentTextureSet, mAtlasRect);
 393       }
 394
 395       TextureSet textureSet;
 396
 397       if(mAttemptAtlasing && !mImpl->mCustomShader)
 398       {
 399         Vector4 atlasRect;
 400         textureSet = mFactoryCache.GetAtlasManager()->Add(atlasRect, rasterizedPixelData);
 401         if(textureSet) // atlasing
 402         {
 403           if(textureSet != currentTextureSet)
 404           {
 405             mImpl->mRenderer.SetTextures(textureSet);
 406           }
 407           mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, atlasRect);
 408           mAtlasRect = atlasRect;
 409           mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
 410         }
 411       }
 412
 413       if(!textureSet) // no atlasing - mAttemptAtlasing is false or adding to atlas is failed
 414       {
 415         Texture texture = Texture::New(Dali::TextureType::TEXTURE_2D, Pixel::RGBA8888, rasterizedPixelData.GetWidth(), rasterizedPixelData.GetHeight());
 416         texture.Upload(rasterizedPixelData);
 417         mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 418
 419         if(mAtlasRect == FULL_TEXTURE_RECT)
 420         {
 421           textureSet = currentTextureSet;
 422         }
 423         else
 424         {
 425           textureSet = TextureSet::New();
 426           mImpl->mRenderer.SetTextures(textureSet);
 427
 428           mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT);
 429           mAtlasRect = FULL_TEXTURE_RECT;
 430         }
 431
 432         if(textureSet)
 433         {
 434           textureSet.SetTexture(0, texture);
 435         }
 436       }
 437
 438       // Rasterized pixels are uploaded to texture. If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 439       Actor actor = mPlacementActor.GetHandle();
 440       if(actor)
 441       {
 442         actor.AddRenderer(mImpl->mRenderer);
 443         // reset the weak handle so that the renderer only get added to actor once
 444         mPlacementActor.Reset();
 445       }
 446
 447       // Svg loaded and ready to display
 448       ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 449     }
 450   }
 451   else if(!mLoadFailed)
 452   {
 453     mLoadFailed = true;
 454
 455     // Remove rasterizing task if we requested before.
 456     if(mRasterizingTask)
 457     {
 458       Dali::AsyncTaskManager::Get().RemoveTask(mRasterizingTask);
 459       mRasterizingTask.Reset();
 460     }
 461
 462     // We don't need to keep tasks anymore. reset now.
 463     if(task == mLoadingTask)
 464     {
 465       mLoadingTask.Reset();
 466     }
 467
 468     Actor actor = mPlacementActor.GetHandle();
 469     if(actor)
 470     {
 471       Vector2 imageSize = Vector2::ZERO;
 472       imageSize         = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
 473       mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize);
 474       actor.AddRenderer(mImpl->mRenderer);
 475     }
 476
 477     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 478   }
 479 }
 480
 481 void SvgVisual::OnSetTransform()
 482 {
 483   if(IsOnScene() && !mLoadFailed)
 484   {
 485     Vector2 size;
 486     if(mDesiredSize.GetWidth() > 0 && mDesiredSize.GetHeight() > 0)
 487     {
 488       // Use desired size
 489       size = Vector2(mDesiredSize.GetWidth(), mDesiredSize.GetHeight());
 490     }
 491     else
 492     {
 493       // Use visual size
 494       size = mImpl->mTransform.GetVisualSize(mImpl->mControlSize);
 495     }
 496
 497     if(size != mRasterizedSize || mDefaultWidth == 0 || mDefaultHeight == 0)
 498     {
 499       mRasterizedSize = size;
 500       AddRasterizationTask(size);
 501     }
 502   }
 503
 504   if(mImpl->mRenderer)
 505   {
 506     mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 507   }
 508 }
 509
 510 void SvgVisual::UpdateShader()
 511 {
 512   if(mImpl->mRenderer)
 513   {
 514     Shader shader = GenerateShader();
 515     mImpl->mRenderer.SetShader(shader);
 516   }
 517 }
 518
 519 Shader SvgVisual::GenerateShader() const
 520 {
 521   Shader shader;
 522   if(!mImpl->mCustomShader)
 523   {
 524     shader = mImageVisualShaderFactory.GetShader(
 525       mFactoryCache,
 526       ImageVisualShaderFeatureBuilder()
 527         .EnableTextureAtlas(mAttemptAtlasing)
 528         .EnableRoundedCorner(IsRoundedCornerRequired())
 529         .EnableBorderline(IsBorderlineRequired()));
 530   }
 531   else
 532   {
 533     shader = Shader::New(mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource().data() : mImpl->mCustomShader->mVertexShader,
 534                          mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource().data() : mImpl->mCustomShader->mFragmentShader,
 535                          mImpl->mCustomShader->mHints);
 536
 537     shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
 538   }
 539   return shader;
 540 }
 541
 542 } // namespace Internal
 543
 544 } // namespace Toolkit
 545
 546 } // namespace Dali