dali-toolkit/internal/visuals/visual-factory-cache.cpp

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