dali-toolkit/internal/visuals/svg/svg-visual.cpp

   1 /*
   2  * Copyright (c) 2023 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::ZERO),
  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   if(DALI_UNLIKELY(mImpl == nullptr))
 364   {
 365     DALI_LOG_ERROR("Fatal error!! already destroyed object callback called! SvgVisual : %p, url : %s, task : %p\n", this, mImageUrl.GetUrl().c_str(), task.Get());
 366     return;
 367   }
 368
 369   if(task->HasSucceeded())
 370   {
 371     PixelData rasterizedPixelData = task->GetPixelData();
 372     if(mDefaultWidth == 0 || mDefaultHeight == 0)
 373     {
 374       task->GetRenderer().GetDefaultSize(mDefaultWidth, mDefaultHeight);
 375     }
 376
 377     // We don't need to keep tasks anymore. reset now.
 378     if(task == mLoadingTask)
 379     {
 380       mLoadingTask.Reset();
 381     }
 382     if(task == mRasterizingTask)
 383     {
 384       mRasterizingTask.Reset();
 385     }
 386
 387     // Rasterization success
 388     if(rasterizedPixelData && IsOnScene())
 389     {
 390       mRasterizedSize.x = static_cast<float>(rasterizedPixelData.GetWidth());
 391       mRasterizedSize.y = static_cast<float>(rasterizedPixelData.GetHeight());
 392
 393       TextureSet currentTextureSet = mImpl->mRenderer.GetTextures();
 394       if(mImpl->mFlags & Impl::IS_ATLASING_APPLIED)
 395       {
 396         mFactoryCache.GetAtlasManager()->Remove(currentTextureSet, mAtlasRect);
 397       }
 398
 399       TextureSet textureSet;
 400
 401       if(mAttemptAtlasing && !mImpl->mCustomShader)
 402       {
 403         Vector4 atlasRect;
 404         textureSet = mFactoryCache.GetAtlasManager()->Add(atlasRect, rasterizedPixelData);
 405         if(textureSet) // atlasing
 406         {
 407           if(textureSet != currentTextureSet)
 408           {
 409             mImpl->mRenderer.SetTextures(textureSet);
 410           }
 411           mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, atlasRect);
 412           mAtlasRect = atlasRect;
 413           mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
 414         }
 415       }
 416
 417       if(!textureSet) // no atlasing - mAttemptAtlasing is false or adding to atlas is failed
 418       {
 419         Texture texture = Texture::New(Dali::TextureType::TEXTURE_2D, Pixel::RGBA8888, rasterizedPixelData.GetWidth(), rasterizedPixelData.GetHeight());
 420         texture.Upload(rasterizedPixelData);
 421         mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 422
 423         if(mAtlasRect == FULL_TEXTURE_RECT)
 424         {
 425           textureSet = currentTextureSet;
 426         }
 427         else
 428         {
 429           textureSet = TextureSet::New();
 430           mImpl->mRenderer.SetTextures(textureSet);
 431
 432           mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT);
 433           mAtlasRect = FULL_TEXTURE_RECT;
 434         }
 435
 436         if(textureSet)
 437         {
 438           textureSet.SetTexture(0, texture);
 439         }
 440       }
 441
 442       // Rasterized pixels are uploaded to texture. If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 443       Actor actor = mPlacementActor.GetHandle();
 444       if(actor)
 445       {
 446         actor.AddRenderer(mImpl->mRenderer);
 447         // reset the weak handle so that the renderer only get added to actor once
 448         mPlacementActor.Reset();
 449       }
 450
 451       // Svg loaded and ready to display
 452       ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 453     }
 454   }
 455   else if(!mLoadFailed)
 456   {
 457     mLoadFailed = true;
 458
 459     // Remove rasterizing task if we requested before.
 460     if(mRasterizingTask)
 461     {
 462       Dali::AsyncTaskManager::Get().RemoveTask(mRasterizingTask);
 463       mRasterizingTask.Reset();
 464     }
 465
 466     // We don't need to keep tasks anymore. reset now.
 467     if(task == mLoadingTask)
 468     {
 469       mLoadingTask.Reset();
 470     }
 471
 472     Actor actor = mPlacementActor.GetHandle();
 473     if(actor)
 474     {
 475       Vector2 imageSize = Vector2::ZERO;
 476       imageSize         = actor.GetProperty(Actor::Property::SIZE).Get<Vector2>();
 477       mFactoryCache.UpdateBrokenImageRenderer(mImpl->mRenderer, imageSize);
 478       actor.AddRenderer(mImpl->mRenderer);
 479     }
 480
 481     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 482   }
 483 }
 484
 485 void SvgVisual::OnSetTransform()
 486 {
 487   if(IsOnScene() && !mLoadFailed)
 488   {
 489     Vector2 size;
 490     if(mDesiredSize.GetWidth() > 0 && mDesiredSize.GetHeight() > 0)
 491     {
 492       // Use desired size
 493       size = Vector2(mDesiredSize.GetWidth(), mDesiredSize.GetHeight());
 494     }
 495     else
 496     {
 497       // Use visual size
 498       size = mImpl->mTransform.GetVisualSize(mImpl->mControlSize);
 499     }
 500
 501     if(size != mRasterizedSize || mDefaultWidth == 0 || mDefaultHeight == 0)
 502     {
 503       mRasterizedSize = size;
 504       AddRasterizationTask(size);
 505     }
 506   }
 507
 508   if(mImpl->mRenderer)
 509   {
 510     mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 511   }
 512 }
 513
 514 void SvgVisual::UpdateShader()
 515 {
 516   if(mImpl->mRenderer)
 517   {
 518     Shader shader = GenerateShader();
 519     mImpl->mRenderer.SetShader(shader);
 520   }
 521 }
 522
 523 Shader SvgVisual::GenerateShader() const
 524 {
 525   Shader shader;
 526   if(!mImpl->mCustomShader)
 527   {
 528     shader = mImageVisualShaderFactory.GetShader(
 529       mFactoryCache,
 530       ImageVisualShaderFeatureBuilder()
 531         .EnableTextureAtlas(mAttemptAtlasing)
 532         .EnableRoundedCorner(IsRoundedCornerRequired())
 533         .EnableBorderline(IsBorderlineRequired()));
 534   }
 535   else
 536   {
 537     shader = Shader::New(mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource().data() : mImpl->mCustomShader->mVertexShader,
 538                          mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource().data() : mImpl->mCustomShader->mFragmentShader,
 539                          mImpl->mCustomShader->mHints);
 540
 541     shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
 542   }
 543   return shader;
 544 }
 545
 546 } // namespace Internal
 547
 548 } // namespace Toolkit
 549
 550 } // namespace Dali