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