dali-toolkit/internal/visuals/visual-factory-cache.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 // CLASS HEADER
  18 #include "visual-factory-cache.h"
  19
  20 // EXTERNAL INCLUDES
  21 #include <dali/devel-api/adaptor-framework/image-loading.h>
  22 #include <dali/devel-api/common/hash.h>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali-toolkit/devel-api/utility/npatch-helper.h>
  26 #include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
  27 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
  28 #include <dali-toolkit/internal/visuals/color/color-visual.h>
  29 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
  30 #include <dali-toolkit/internal/visuals/svg/svg-visual.h>
  31 #include <dali-toolkit/internal/visuals/visual-string-constants.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 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
  43 }
  44
  45 VisualFactoryCache::VisualFactoryCache(bool preMultiplyOnLoad)
  46 : mSvgRasterizeManager(nullptr),
  47   mVectorAnimationManager(nullptr),
  48   mPreMultiplyOnLoad(preMultiplyOnLoad),
  49   mBrokenImageInfoContainer(),
  50   mDefaultBrokenImageUrl(""),
  51   mUseDefaultBrokenImageOnly(true)
  52 {
  53 }
  54
  55 VisualFactoryCache::~VisualFactoryCache()
  56 {
  57 }
  58
  59 Geometry VisualFactoryCache::GetGeometry(GeometryType type)
  60 {
  61   if(!mGeometry[type] && type == QUAD_GEOMETRY)
  62   {
  63     mGeometry[type] = CreateQuadGeometry();
  64   }
  65
  66   return mGeometry[type];
  67 }
  68
  69 void VisualFactoryCache::SaveGeometry(GeometryType type, Geometry geometry)
  70 {
  71   mGeometry[type] = geometry;
  72 }
  73
  74 Shader VisualFactoryCache::GetShader(ShaderType type)
  75 {
  76   return mShader[type];
  77 }
  78
  79 void VisualFactoryCache::SaveShader(ShaderType type, Shader shader)
  80 {
  81   mShader[type] = shader;
  82 }
  83
  84 Geometry VisualFactoryCache::CreateQuadGeometry()
  85 {
  86   const float halfWidth  = 0.5f;
  87   const float halfHeight = 0.5f;
  88   struct QuadVertex
  89   {
  90     Vector2 position;
  91   };
  92   QuadVertex quadVertexData[4] =
  93     {
  94       {Vector2(-halfWidth, -halfHeight)},
  95       {Vector2(-halfWidth, halfHeight)},
  96       {Vector2(halfWidth, -halfHeight)},
  97       {Vector2(halfWidth, halfHeight)}};
  98
  99   Property::Map quadVertexFormat;
 100   quadVertexFormat["aPosition"] = Property::VECTOR2;
 101   VertexBuffer quadVertices     = VertexBuffer::New(quadVertexFormat);
 102   quadVertices.SetData(quadVertexData, 4);
 103
 104   // Create the geometry object
 105   Geometry geometry = Geometry::New();
 106   geometry.AddVertexBuffer(quadVertices);
 107   geometry.SetType(Geometry::TRIANGLE_STRIP);
 108
 109   return geometry;
 110 }
 111
 112 ImageAtlasManagerPtr VisualFactoryCache::GetAtlasManager()
 113 {
 114   if(!mAtlasManager)
 115   {
 116     mAtlasManager = new ImageAtlasManager();
 117     mAtlasManager->SetBrokenImage(mDefaultBrokenImageUrl);
 118   }
 119
 120   return mAtlasManager;
 121 }
 122
 123 TextureManager& VisualFactoryCache::GetTextureManager()
 124 {
 125   return mTextureManager;
 126 }
 127
 128 NPatchLoader& VisualFactoryCache::GetNPatchLoader()
 129 {
 130   return mNPatchLoader;
 131 }
 132
 133 SvgRasterizeManager* VisualFactoryCache::GetSVGRasterizationManager()
 134 {
 135   if(!mSvgRasterizeManager)
 136   {
 137     mSvgRasterizeManager = std::unique_ptr<SvgRasterizeManager>(new SvgRasterizeManager());
 138   }
 139   return mSvgRasterizeManager.get();
 140 }
 141
 142 VectorAnimationManager& VisualFactoryCache::GetVectorAnimationManager()
 143 {
 144   if(!mVectorAnimationManager)
 145   {
 146     mVectorAnimationManager = std::unique_ptr<VectorAnimationManager>(new VectorAnimationManager());
 147   }
 148   return *mVectorAnimationManager;
 149 }
 150
 151 Geometry VisualFactoryCache::CreateGridGeometry(Uint16Pair gridSize)
 152 {
 153   uint16_t gridWidth  = gridSize.GetWidth();
 154   uint16_t gridHeight = gridSize.GetHeight();
 155
 156   // Create vertices
 157   Vector<Vector2> vertices;
 158   vertices.Reserve((gridWidth + 1) * (gridHeight + 1));
 159
 160   for(int y = 0; y < gridHeight + 1; ++y)
 161   {
 162     for(int x = 0; x < gridWidth + 1; ++x)
 163     {
 164       vertices.PushBack(Vector2((float)x / gridWidth - 0.5f, (float)y / gridHeight - 0.5f));
 165     }
 166   }
 167
 168   // Create indices
 169   Vector<unsigned short> indices;
 170   indices.Reserve((gridWidth + 2) * gridHeight * 2 - 2);
 171
 172   for(unsigned int row = 0u; row < gridHeight; ++row)
 173   {
 174     unsigned int rowStartIndex     = row * (gridWidth + 1u);
 175     unsigned int nextRowStartIndex = rowStartIndex + gridWidth + 1u;
 176
 177     if(row != 0u) // degenerate index on non-first row
 178     {
 179       indices.PushBack(rowStartIndex);
 180     }
 181
 182     for(unsigned int column = 0u; column < gridWidth + 1u; column++) // main strip
 183     {
 184       indices.PushBack(rowStartIndex + column);
 185       indices.PushBack(nextRowStartIndex + column);
 186     }
 187
 188     if(row != gridHeight - 1u) // degenerate index on non-last row
 189     {
 190       indices.PushBack(nextRowStartIndex + gridWidth);
 191     }
 192   }
 193
 194   Property::Map vertexFormat;
 195   vertexFormat["aPosition"] = Property::VECTOR2;
 196   VertexBuffer vertexBuffer = VertexBuffer::New(vertexFormat);
 197   if(vertices.Size() > 0)
 198   {
 199     vertexBuffer.SetData(&vertices[0], vertices.Size());
 200   }
 201
 202   Property::Map indexFormat;
 203   indexFormat["indices"]         = Property::INTEGER;
 204   VertexBuffer indexVertexBuffer = VertexBuffer::New(indexFormat);
 205
 206   // Create the geometry object
 207   Geometry geometry = Geometry::New();
 208   geometry.AddVertexBuffer(vertexBuffer);
 209   if(indices.Size() > 0)
 210   {
 211     geometry.SetIndexBuffer(&indices[0], indices.Size());
 212   }
 213
 214   geometry.SetType(Geometry::TRIANGLE_STRIP);
 215
 216   return geometry;
 217 }
 218
 219 Texture VisualFactoryCache::GetBrokenVisualImage(uint32_t brokenIndex)
 220 {
 221   if(!(mBrokenImageInfoContainer[brokenIndex].texture))
 222   {
 223     PixelData          pixelData;
 224     Devel::PixelBuffer pixelBuffer = LoadImageFromFile(mBrokenImageInfoContainer[brokenIndex].url);
 225     if(pixelBuffer)
 226     {
 227       pixelData                                      = Devel::PixelBuffer::Convert(pixelBuffer); // takes ownership of buffer
 228       mBrokenImageInfoContainer[brokenIndex].texture = Texture::New(Dali::TextureType::TEXTURE_2D, pixelData.GetPixelFormat(), pixelData.GetWidth(), pixelData.GetHeight());
 229       mBrokenImageInfoContainer[brokenIndex].texture.Upload(pixelData);
 230       mBrokenImageInfoContainer[brokenIndex].width  = pixelData.GetWidth();
 231       mBrokenImageInfoContainer[brokenIndex].height = pixelData.GetHeight();
 232     }
 233   }
 234   return mBrokenImageInfoContainer[brokenIndex].texture;
 235 }
 236
 237 void VisualFactoryCache::SetPreMultiplyOnLoad(bool preMultiply)
 238 {
 239   mPreMultiplyOnLoad = preMultiply;
 240 }
 241
 242 bool VisualFactoryCache::GetPreMultiplyOnLoad()
 243 {
 244   return mPreMultiplyOnLoad;
 245 }
 246
 247 void VisualFactoryCache::SetBrokenImageUrl(std::string& defaultBrokenUrl, const std::vector<std::string>& brokenImageUrlList)
 248 {
 249   mUseDefaultBrokenImageOnly = false;
 250   mBrokenImageInfoContainer.clear();
 251   mBrokenImageInfoContainer.assign(brokenImageUrlList.size(), BrokenImageInfo());
 252   for(unsigned int i = 0; i < brokenImageUrlList.size(); i++)
 253   {
 254     mBrokenImageInfoContainer[i].url = brokenImageUrlList[i];
 255   }
 256
 257   mDefaultBrokenImageUrl = defaultBrokenUrl;
 258 }
 259
 260 VisualUrl::Type VisualFactoryCache::GetBrokenImageVisualType(int index)
 261 {
 262   return mBrokenImageInfoContainer[index].visualType;
 263 }
 264
 265 Geometry VisualFactoryCache::GetNPatchGeometry(int index)
 266 {
 267   Geometry          geometry;
 268   const NPatchData* data;
 269   if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
 270   {
 271     if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
 272     {
 273       geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
 274       if(!geometry)
 275       {
 276         geometry = NPatchHelper::CreateGridGeometry(Uint16Pair(3, 3));
 277         SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
 278       }
 279     }
 280     else if(data->GetStretchPixelsX().Size() > 0 || data->GetStretchPixelsY().Size() > 0)
 281     {
 282       Uint16Pair gridSize(2 * data->GetStretchPixelsX().Size() + 1, 2 * data->GetStretchPixelsY().Size() + 1);
 283       geometry = NPatchHelper::CreateGridGeometry(gridSize);
 284     }
 285   }
 286   else
 287   {
 288     // no N patch data so use default geometry
 289     geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
 290     if(!geometry)
 291     {
 292       geometry = NPatchHelper::CreateGridGeometry(Uint16Pair(3, 3));
 293       SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
 294     }
 295   }
 296   return geometry;
 297 }
 298
 299 Shader VisualFactoryCache::GetNPatchShader(int index)
 300 {
 301   Shader            shader;
 302   const NPatchData* data;
 303   // 0 is either no data (load failed?) or no stretch regions on image
 304   // for both cases we use the default shader
 305   NPatchUtility::StretchRanges::SizeType xStretchCount = 0;
 306   NPatchUtility::StretchRanges::SizeType yStretchCount = 0;
 307
 308   // ask loader for the regions
 309   if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data))
 310   {
 311     xStretchCount = data->GetStretchPixelsX().Count();
 312     yStretchCount = data->GetStretchPixelsY().Count();
 313   }
 314
 315   if(DALI_LIKELY((xStretchCount == 0 && yStretchCount == 0) || (xStretchCount == 1 && yStretchCount == 1)))
 316   {
 317     shader = GetShader(VisualFactoryCache::NINE_PATCH_SHADER);
 318     if(DALI_UNLIKELY(!shader))
 319     {
 320       shader = Shader::New(SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, SHADER_NPATCH_VISUAL_SHADER_FRAG);
 321
 322       // Only cache vanilla 9 patch shaders
 323       SaveShader(VisualFactoryCache::NINE_PATCH_SHADER, shader);
 324     }
 325   }
 326   else if(xStretchCount > 0 || yStretchCount > 0)
 327   {
 328     std::stringstream vertexShader;
 329     vertexShader << "#define FACTOR_SIZE_X " << xStretchCount + 2 << "\n"
 330                  << "#define FACTOR_SIZE_Y " << yStretchCount + 2 << "\n"
 331                  << SHADER_NPATCH_VISUAL_SHADER_VERT;
 332     shader = Shader::New(vertexShader.str(), SHADER_NPATCH_VISUAL_SHADER_FRAG);
 333   }
 334   return shader;
 335 }
 336
 337 void VisualFactoryCache::ApplyTextureAndUniforms(Renderer& renderer, int index)
 338 {
 339   const NPatchData* data;
 340   TextureSet        textureSet;
 341   if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
 342   {
 343     textureSet                               = data->GetTextures();
 344     mBrokenImageInfoContainer[index].texture = textureSet.GetTexture(0);
 345     NPatchHelper::ApplyTextureAndUniforms(renderer, data);
 346     renderer.SetTextures(textureSet);
 347   }
 348 }
 349
 350 void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size, const bool& rendererIsImage)
 351 {
 352   bool useDefaultBrokenImage = false;
 353   if(mBrokenImageInfoContainer.size() == 0)
 354   {
 355     useDefaultBrokenImage = true;
 356   }
 357
 358   // Load Information for broken image
 359   for(uint32_t index = 0; (index < mBrokenImageInfoContainer.size()) && !useDefaultBrokenImage; index++)
 360   {
 361     if(mBrokenImageInfoContainer[index].width == 0 && mBrokenImageInfoContainer[index].height == 0)
 362     {
 363       if(!mBrokenImageInfoContainer[index].url.empty())
 364       {
 365         VisualUrl visualUrl(mBrokenImageInfoContainer[index].url);
 366         mBrokenImageInfoContainer[index].visualType = visualUrl.GetType();
 367         if(mBrokenImageInfoContainer[index].visualType == VisualUrl::Type::N_PATCH)
 368         {
 369           const NPatchData* data;
 370           Rect<int>         border;
 371           mBrokenImageInfoContainer[index].npatchId = mNPatchLoader.Load(mTextureManager, NULL, mBrokenImageInfoContainer[index].url, border, mPreMultiplyOnLoad, true);
 372           if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
 373           {
 374             mBrokenImageInfoContainer[index].width  = data->GetCroppedWidth();
 375             mBrokenImageInfoContainer[index].height = data->GetCroppedHeight();
 376           }
 377           else
 378           {
 379             DALI_LOG_ERROR("Can't update renderer for broken image. maybe image loading is failed [index:%d] [path:%s] \n", index, mBrokenImageInfoContainer[index].url.c_str());
 380             useDefaultBrokenImage = true;
 381           }
 382         }
 383         else
 384         {
 385           if(!GetBrokenVisualImage(index))
 386           {
 387             DALI_LOG_ERROR("Can't update renderer for broken image. maybe image loading is failed [index:%d] [path:%s] \n", index, mBrokenImageInfoContainer[index].url.c_str());
 388             useDefaultBrokenImage = true;
 389           }
 390         }
 391       }
 392     }
 393   }
 394
 395   if(!mUseDefaultBrokenImageOnly && useDefaultBrokenImage)
 396   {
 397     // Clear broken info
 398     mBrokenImageInfoContainer.clear();
 399
 400     // assign for broken image
 401     const int defaultBrokenIndex = 0;
 402     mBrokenImageInfoContainer.assign(1, BrokenImageInfo());
 403     mBrokenImageInfoContainer[defaultBrokenIndex].url = mDefaultBrokenImageUrl;
 404     VisualUrl visualUrl(mBrokenImageInfoContainer[defaultBrokenIndex].url);
 405     mBrokenImageInfoContainer[defaultBrokenIndex].visualType = visualUrl.GetType();
 406     mUseDefaultBrokenImageOnly                               = true;
 407   }
 408
 409   // Set Texutre to renderer
 410   int brokenIndex = GetProperBrokenImageIndex(size);
 411   if(GetBrokenImageVisualType(brokenIndex) == VisualUrl::N_PATCH)
 412   {
 413     // Set geometry and shader for npatch
 414     Geometry geometry = GetNPatchGeometry(brokenIndex);
 415     Shader   shader   = GetNPatchShader(brokenIndex);
 416     renderer.SetGeometry(geometry);
 417     renderer.SetShader(shader);
 418     ApplyTextureAndUniforms(renderer, brokenIndex);
 419   }
 420   else
 421   {
 422     // Create single image renderer only if rederer is not use normal ImageShader. i.e. npatch visual.
 423     if(!rendererIsImage)
 424     {
 425       Geometry geometry = GetGeometry(QUAD_GEOMETRY);
 426       Shader   shader   = GetShader(IMAGE_SHADER);
 427       if(!shader)
 428       {
 429         std::string vertexShader   = std::string(Dali::Shader::GetVertexShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_VERT.data());
 430         std::string fragmentShader = std::string(Dali::Shader::GetFragmentShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_FRAG.data());
 431         shader                     = Shader::New(vertexShader, fragmentShader);
 432         shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
 433         SaveShader(IMAGE_SHADER, shader);
 434       }
 435       renderer.SetGeometry(geometry);
 436       renderer.SetShader(shader);
 437     }
 438     Texture    brokenImage = GetBrokenVisualImage(brokenIndex);
 439     TextureSet textureSet  = TextureSet::New();
 440     textureSet.SetTexture(0u, brokenImage);
 441     renderer.SetTextures(textureSet);
 442   }
 443 }
 444
 445 int32_t VisualFactoryCache::GetProperBrokenImageIndex(const Vector2& size)
 446 {
 447   // Sets the default broken type
 448   int32_t returnIndex = 0;
 449   if((size.width == 0 || size.height == 0) || mUseDefaultBrokenImageOnly)
 450   {
 451     // To do : Need to add observer about size
 452     return returnIndex;
 453   }
 454
 455   // Find the proper value if we know the size of the image
 456   for(int32_t index = static_cast<int32_t>(mBrokenImageInfoContainer.size()) - 1; index >= 0; index--)
 457   {
 458     // Skip if the value is not set
 459     if(mBrokenImageInfoContainer[index].width == 0 || mBrokenImageInfoContainer[index].height == 0)
 460     {
 461       continue;
 462     }
 463
 464     if(mBrokenImageInfoContainer[index].width < size.width && mBrokenImageInfoContainer[index].height < size.height)
 465     {
 466       returnIndex = index;
 467       break;
 468     }
 469   }
 470
 471   return returnIndex;
 472 }
 473
 474 } // namespace Internal
 475
 476 } // namespace Toolkit
 477
 478 } // namespace Dali