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       if(!mVectorRenderer.Load(buffer, meanDpi))
 234       {
 235         mLoadFailed = true;
 236         DALI_LOG_ERROR("SvgVisual::Load: Failed to load file! [%s]\n", mImageUrl.GetUrl().c_str());
 237         return;
 238       }
 239       mVectorRenderer.GetDefaultSize(mDefaultWidth, mDefaultHeight);
 240     }
 241     else
 242     {
 243       mLoadFailed = true;
 244       DALI_LOG_ERROR("SvgVisual::Load: Failed to read file! [%s]\n", mImageUrl.GetUrl().c_str());
 245     }
 246   }
 247 }
 248
 249 void SvgVisual::AddRasterizationTask(const Vector2& size)
 250 {
 251   if(mImpl->mRenderer)
 252   {
 253     unsigned int width  = static_cast<unsigned int>(size.width);
 254     unsigned int height = static_cast<unsigned int>(size.height);
 255
 256     Vector2 dpi     = Stage::GetCurrent().GetDpi();
 257     float   meanDpi = (dpi.height + dpi.width) * 0.5f;
 258
 259     RasterizingTaskPtr newTask = new RasterizingTask(this, mVectorRenderer, mImageUrl, meanDpi, width, height);
 260     if(IsSynchronousLoadingRequired() && mImageUrl.IsLocalResource())
 261     {
 262       newTask->Load();
 263       newTask->Rasterize();
 264       ApplyRasterizedImage(newTask->GetVectorRenderer(), newTask->GetPixelData(), newTask->IsLoaded());
 265     }
 266     else
 267     {
 268       mFactoryCache.GetSVGRasterizationThread()->AddTask(newTask);
 269     }
 270   }
 271 }
 272
 273 void SvgVisual::ApplyRasterizedImage(VectorImageRenderer vectorRenderer, PixelData rasterizedPixelData, bool isLoaded)
 274 {
 275   if(isLoaded && rasterizedPixelData && IsOnScene())
 276   {
 277     TextureSet currentTextureSet = mImpl->mRenderer.GetTextures();
 278     if(mImpl->mFlags & Impl::IS_ATLASING_APPLIED)
 279     {
 280       mFactoryCache.GetAtlasManager()->Remove(currentTextureSet, mAtlasRect);
 281     }
 282
 283     TextureSet textureSet;
 284
 285     if(mAttemptAtlasing && !mImpl->mCustomShader)
 286     {
 287       Vector4 atlasRect;
 288       textureSet = mFactoryCache.GetAtlasManager()->Add(atlasRect, rasterizedPixelData);
 289       if(textureSet) // atlasing
 290       {
 291         if(textureSet != currentTextureSet)
 292         {
 293           mImpl->mRenderer.SetTextures(textureSet);
 294         }
 295         mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, atlasRect);
 296         mAtlasRect = atlasRect;
 297         mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
 298       }
 299     }
 300
 301     if(!textureSet) // no atlasing - mAttemptAtlasing is false or adding to atlas is failed
 302     {
 303       Texture texture = Texture::New(Dali::TextureType::TEXTURE_2D, Pixel::RGBA8888, rasterizedPixelData.GetWidth(), rasterizedPixelData.GetHeight());
 304       texture.Upload(rasterizedPixelData);
 305       mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
 306
 307       if(mAtlasRect == FULL_TEXTURE_RECT)
 308       {
 309         textureSet = currentTextureSet;
 310       }
 311       else
 312       {
 313         textureSet = TextureSet::New();
 314         mImpl->mRenderer.SetTextures(textureSet);
 315
 316         mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT);
 317         mAtlasRect = FULL_TEXTURE_RECT;
 318       }
 319
 320       if(textureSet)
 321       {
 322         textureSet.SetTexture(0, texture);
 323       }
 324     }
 325
 326     // Rasterized pixels are uploaded to texture. If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 327     Actor actor = mPlacementActor.GetHandle();
 328     if(actor)
 329     {
 330       actor.AddRenderer(mImpl->mRenderer);
 331       // reset the weak handle so that the renderer only get added to actor once
 332       mPlacementActor.Reset();
 333     }
 334
 335     // Svg loaded and ready to display
 336     ResourceReady(Toolkit::Visual::ResourceStatus::READY);
 337   }
 338   else if(!isLoaded || !rasterizedPixelData)
 339   {
 340     Actor actor = mPlacementActor.GetHandle();
 341     if(actor)
 342     {
 343       TextureSet textureSet = mImpl->mRenderer.GetTextures();
 344
 345       Texture brokenImage = mFactoryCache.GetBrokenVisualImage();
 346       textureSet.SetTexture(0u, brokenImage);
 347
 348       actor.AddRenderer(mImpl->mRenderer);
 349     }
 350
 351     ResourceReady(Toolkit::Visual::ResourceStatus::FAILED);
 352   }
 353 }
 354
 355 void SvgVisual::OnSetTransform()
 356 {
 357   Vector2 visualSize = mImpl->mTransform.GetVisualSize(mImpl->mControlSize);
 358
 359   if(IsOnScene() && !mLoadFailed)
 360   {
 361     if(visualSize != mVisualSize)
 362     {
 363       AddRasterizationTask(visualSize);
 364       mVisualSize = visualSize;
 365     }
 366   }
 367
 368   if(mImpl->mRenderer)
 369   {
 370     mImpl->mTransform.RegisterUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 371   }
 372 }
 373
 374 bool SvgVisual::IsResourceReady() const
 375 {
 376   return (mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::READY ||
 377           mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED);
 378 }
 379
 380 } // namespace Internal
 381
 382 } // namespace Toolkit
 383
 384 } // namespace Dali