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