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

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