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