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

   1 /*
   2  * Copyright (c) 2021 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-rasterize-thread.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/adaptor-framework/file-loader.h>
  31 #include <dali/devel-api/common/stage.h>
  32 #include <dali/integration-api/debug.h>
  33
  34 namespace Dali
  35 {
  36 namespace Toolkit
  37 {
  38 namespace Internal
  39 {
  40 namespace
  41 {
  42 // property name
  43 const Dali::Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  44
  45 } // namespace
  46
  47 SvgVisualPtr SvgVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties)
  48 {
  49   SvgVisualPtr svgVisual(new SvgVisual(factoryCache, shaderFactory, imageUrl));
  50   svgVisual->Load();
  51   svgVisual->SetProperties(properties);
  52   svgVisual->Initialize();
  53   return svgVisual;
  54 }
  55
  56 SvgVisualPtr SvgVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl)
  57 {
  58   SvgVisualPtr svgVisual(new SvgVisual(factoryCache, shaderFactory, imageUrl));
  59   svgVisual->Load();
  60   svgVisual->Initialize();
  61   return svgVisual;
  62 }
  63
  64 SvgVisual::SvgVisual(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl)
  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   mVisualSize(Vector2::ZERO),
  74   mLoadFailed(false),
  75   mAttemptAtlasing(false)
  76 {
  77   // the rasterized image is with pre-multiplied alpha format
  78   mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA;
  79 }
  80
  81 SvgVisual::~SvgVisual()
  82 {
  83 }
  84
  85 void SvgVisual::OnInitialize()
  86 {
  87   Shader shader;
  88   if(!mImpl->mCustomShader)
  89   {
  90     shader = mImageVisualShaderFactory.GetShader(mFactoryCache, mAttemptAtlasing, true, IsRoundedCornerRequired());
  91   }
  92   else
  93   {
  94     shader = Shader::New(mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource().data() : mImpl->mCustomShader->mVertexShader,
  95                          mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource().data() : mImpl->mCustomShader->mFragmentShader,
  96                          mImpl->mCustomShader->mHints);
  97
  98     shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
  99   }
 100
 101   Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY);
 102   mImpl->mRenderer  = Renderer::New(geometry, shader);
 103 }
 104
 105 void SvgVisual::DoSetProperties(const Property::Map& propertyMap)
 106 {
 107   // url already passed in from constructor
 108   for(Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter)
 109   {
 110     KeyValuePair keyValue = propertyMap.GetKeyValue(iter);
 111     if(keyValue.first.type == Property::Key::INDEX)
 112     {
 113       DoSetProperty(keyValue.first.indexKey, keyValue.second);
 114     }
 115     else if(keyValue.first == IMAGE_ATLASING)
 116     {
 117       DoSetProperty(Toolkit::ImageVisual::Property::ATLASING, keyValue.second);
 118     }
 119     else if(keyValue.first == SYNCHRONOUS_LOADING)
 120     {
 121       DoSetProperty(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second);
 122     }
 123   }
 124 }
 125
 126 void SvgVisual::DoSetProperty(Property::Index index, const Property::Value& value)
 127 {
 128   switch(index)
 129   {
 130     case Toolkit::ImageVisual::Property::ATLASING:
 131     {
 132       value.Get(mAttemptAtlasing);
 133       break;
 134     }
 135     case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING:
 136     {
 137       bool sync = false;
 138       if(value.Get(sync))
 139       {
 140         if(sync)
 141         {
 142           mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 143         }
 144         else
 145         {
 146           mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 147         }
 148       }
 149       else
 150       {
 151         DALI_LOG_ERROR("ImageVisual: synchronousLoading property has incorrect type\n");
 152       }
 153       break;
 154     }
 155   }
 156 }
 157
 158 void SvgVisual::DoSetOnScene(Actor& actor)
 159 {
 160   TextureSet textureSet = TextureSet::New();
 161   mImpl->mRenderer.SetTextures(textureSet);
 162
 163   // Register transform properties
 164   mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 165
 166   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 167
 168   // Hold the weak handle of the placement actor and delay the adding of renderer until the svg rasterization is finished.
 169   mPlacementActor = actor;
 170
 171   if(mLoadFailed)
 172   {
 173     Texture brokenImage = mFactoryCache.GetBrokenVisualImage();
 174     textureSet.SetTexture(0u, brokenImage);
 175
 176     actor.AddRenderer(mImpl->mRenderer);
 177
 178     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 179   }
 180   else
 181   {
 182     // SVG visual needs it's size set before it can be rasterized hence set ResourceReady once on stage
 183     ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 184   }
 185 }
 186
 187 void SvgVisual::DoSetOffScene(Actor& actor)
 188 {
 189   mFactoryCache.GetSVGRasterizationThread()->RemoveTask(this);
 190
 191   actor.RemoveRenderer(mImpl->mRenderer);
 192   mPlacementActor.Reset();
 193
 194   // Reset the visual size to zero so that when adding the actor back to stage the SVG rasterization is forced
 195   mVisualSize = Vector2::ZERO;
 196 }
 197
 198 void SvgVisual::GetNaturalSize(Vector2& naturalSize)
 199 {
 200   naturalSize.x = mDefaultWidth;
 201   naturalSize.y = mDefaultHeight;
 202 }
 203
 204 void SvgVisual::DoCreatePropertyMap(Property::Map& map) const
 205 {
 206   map.Clear();
 207   map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::SVG);
 208   if(mImageUrl.IsValid())
 209   {
 210     map.Insert(Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl());
 211     map.Insert(Toolkit::ImageVisual::Property::ATLASING, mAttemptAtlasing);
 212   }
 213   map.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, IsSynchronousLoadingRequired());
 214 }
 215
 216 void SvgVisual::DoCreateInstancePropertyMap(Property::Map& map) const
 217 {
 218   // Do nothing
 219 }
 220
 221 void SvgVisual::Load()
 222 {
 223   // load remote resource on svg rasterize thread.
 224   if(mImageUrl.IsLocalResource())
 225   {
 226     Dali::Vector<uint8_t> buffer;
 227     if(Dali::FileLoader::ReadFile(mImageUrl.GetUrl(), buffer))
 228     {
 229       buffer.PushBack('\0');
 230
 231       Vector2 dpi     = Stage::GetCurrent().GetDpi();
 232       float   meanDpi = (dpi.height + dpi.width) * 0.5f;
 233       DALI_LOG_RELEASE_INFO("SvgVisual::Load: Try load file! [%s]\n", mImageUrl.GetUrl().c_str());
 234
 235       if(!mVectorRenderer.Load(buffer, meanDpi))
 236       {
 237         mLoadFailed = true;
 238         DALI_LOG_ERROR("SvgVisual::Load: Failed to load file! [%s]\n", mImageUrl.GetUrl().c_str());
 239         return;
 240       }
 241       mVectorRenderer.GetDefaultSize(mDefaultWidth, mDefaultHeight);
 242     }
 243     else
 244     {
 245       mLoadFailed = true;
 246       DALI_LOG_ERROR("SvgVisual::Load: Failed to read file! [%s]\n", mImageUrl.GetUrl().c_str());
 247     }
 248   }
 249 }
 250
 251 void SvgVisual::AddRasterizationTask(const Vector2& size)
 252 {
 253   if(mImpl->mRenderer)
 254   {
 255     unsigned int width  = static_cast<unsigned int>(size.width);
 256     unsigned int height = static_cast<unsigned int>(size.height);
 257
 258     Vector2 dpi     = Stage::GetCurrent().GetDpi();
 259     float   meanDpi = (dpi.height + dpi.width) * 0.5f;
 260
 261     RasterizingTaskPtr newTask = new RasterizingTask(this, mVectorRenderer, mImageUrl, meanDpi, width, height);
 262     if(IsSynchronousLoadingRequired() && mImageUrl.IsLocalResource())
 263     {
 264       newTask->Load();
 265       newTask->Rasterize();
 266       ApplyRasterizedImage(newTask->GetVectorRenderer(), newTask->GetPixelData(), newTask->IsLoaded());
 267     }
 268     else
 269     {
 270       mFactoryCache.GetSVGRasterizationThread()->AddTask(newTask);
 271     }
 272   }
 273 }
 274
 275 void SvgVisual::ApplyRasterizedImage(VectorImageRenderer vectorRenderer, PixelData rasterizedPixelData, bool isLoaded)
 276 {
 277   if(isLoaded && rasterizedPixelData && IsOnScene())
 278   {
 279     TextureSet currentTextureSet = mImpl->mRenderer.GetTextures();
 280     if(mImpl->mFlags & Impl::IS_ATLASING_APPLIED)
 281     {
 282       mFactoryCache.GetAtlasManager()->Remove(currentTextureSet, mAtlasRect);
 283     }
 284
 285     TextureSet textureSet;
 286
 287     if(mAttemptAtlasing && !mImpl->mCustomShader)
 288     {
 289       Vector4 atlasRect;
 290       textureSet = mFactoryCache.GetAtlasManager()->Add(atlasRect, rasterizedPixelData);
 291       if(textureSet) // atlasing
 292       {
 293         if(textureSet != currentTextureSet)
 294         {
 295           mImpl->mRenderer.SetTextures(textureSet);
 296         }
 297         mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, atlasRect);
 298         mAtlasRect = atlasRect;
 299         mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
 300       }
 301     }
 302
 303     if(!textureSet) // no atlasing - mAttemptAtlasing is false or adding to atlas is failed
 304     {
 305       Texture texture = Texture::New(Dali::TextureType::TEXTURE_2D, Pixel::RGBA8888, rasterizedPixelData.GetWidth(), rasterizedPixelData.GetHeight());
 306       texture.Upload(rasterizedPixelData);
 307       mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 308
 309       if(mAtlasRect == FULL_TEXTURE_RECT)
 310       {
 311         textureSet = currentTextureSet;
 312       }
 313       else
 314       {
 315         textureSet = TextureSet::New();
 316         mImpl->mRenderer.SetTextures(textureSet);
 317
 318         mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT);
 319         mAtlasRect = FULL_TEXTURE_RECT;
 320       }
 321
 322       if(textureSet)
 323       {
 324         textureSet.SetTexture(0, texture);
 325       }
 326     }
 327
 328     // Rasterized pixels are uploaded to texture. If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 329     Actor actor = mPlacementActor.GetHandle();
 330     if(actor)
 331     {
 332       actor.AddRenderer(mImpl->mRenderer);
 333       // reset the weak handle so that the renderer only get added to actor once
 334       mPlacementActor.Reset();
 335     }
 336
 337     // Svg loaded and ready to display
 338     ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 339   }
 340   else if(!isLoaded || !rasterizedPixelData)
 341   {
 342     Actor actor = mPlacementActor.GetHandle();
 343     if(actor)
 344     {
 345       TextureSet textureSet = mImpl->mRenderer.GetTextures();
 346
 347       Texture brokenImage = mFactoryCache.GetBrokenVisualImage();
 348       textureSet.SetTexture(0u, brokenImage);
 349
 350       actor.AddRenderer(mImpl->mRenderer);
 351     }
 352
 353     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 354   }
 355 }
 356
 357 void SvgVisual::OnSetTransform()
 358 {
 359   Vector2 visualSize = mImpl->mTransform.GetVisualSize(mImpl->mControlSize);
 360
 361   if(IsOnScene() && !mLoadFailed)
 362   {
 363     if(visualSize != mVisualSize)
 364     {
 365       AddRasterizationTask(visualSize);
 366       mVisualSize = visualSize;
 367     }
 368   }
 369
 370   if(mImpl->mRenderer)
 371   {
 372     mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 373   }
 374 }
 375
 376 bool SvgVisual::IsResourceReady() const
 377 {
 378   return (mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::READY ||
 379           mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED);
 380 }
 381
 382 } // namespace Internal
 383
 384 } // namespace Toolkit
 385
 386 } // namespace Dali