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