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