[dali_2.3.21] Merge branch 'devel/master'

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / visual-factory-cache.cpp

diff --git a/dali-toolkit/internal/visuals/visual-factory-cache.cpp b/dali-toolkit/internal/visuals/visual-factory-cache.cpp
index 2f5d123..e8b5dbf 100644 (file)
--- a/dali-toolkit/internal/visuals/visual-factory-cache.cpp
+++ b/dali-toolkit/internal/visuals/visual-factory-cache.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,11 +15,16 @@
  */
 
 // CLASS HEADER
-#include "visual-factory-cache.h"
+#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
 
 // EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/environment-variable.h>
 #include <dali/devel-api/adaptor-framework/image-loading.h>
 #include <dali/devel-api/common/hash.h>
+#include <dali/devel-api/scripting/enum-helper.h>
+#include <dali/devel-api/scripting/scripting.h>
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/math/math-utils.h>
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/utility/npatch-helper.h>
@@ -29,7 +34,6 @@
 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
 #include <dali-toolkit/internal/visuals/svg/svg-visual.h>
 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali/integration-api/debug.h>
 
 namespace Dali
 {
@@ -40,11 +44,22 @@ namespace Internal
 namespace
 {
 const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
+
+constexpr auto LOAD_IMAGE_YUV_PLANES_ENV = "DALI_LOAD_IMAGE_YUV_PLANES";
+
+bool NeedToLoadYuvPlanes()
+{
+  auto loadYuvPlanesString = Dali::EnvironmentVariable::GetEnvironmentVariable(LOAD_IMAGE_YUV_PLANES_ENV);
+  bool loadYuvPlanes       = loadYuvPlanesString ? std::atoi(loadYuvPlanesString) : false;
+  return loadYuvPlanes;
 }
 
+} // namespace
+
 VisualFactoryCache::VisualFactoryCache(bool preMultiplyOnLoad)
-: mSvgRasterizeThread(NULL),
-  mVectorAnimationManager(),
+: mLoadYuvPlanes(NeedToLoadYuvPlanes()),
+  mTextureManager(mLoadYuvPlanes),
+  mVectorAnimationManager(nullptr),
   mPreMultiplyOnLoad(preMultiplyOnLoad),
   mBrokenImageInfoContainer(),
   mDefaultBrokenImageUrl(""),
@@ -54,7 +69,6 @@ VisualFactoryCache::VisualFactoryCache(bool preMultiplyOnLoad)
 
 VisualFactoryCache::~VisualFactoryCache()
 {
-  SvgRasterizeThread::TerminateThread(mSvgRasterizeThread);
 }
 
 Geometry VisualFactoryCache::GetGeometry(GeometryType type)
@@ -77,9 +91,11 @@ Shader VisualFactoryCache::GetShader(ShaderType type)
   return mShader[type];
 }
 
-void VisualFactoryCache::SaveShader(ShaderType type, Shader shader)
+Shader VisualFactoryCache::GenerateAndSaveShader(ShaderType type, std::string_view vertexShader, std::string_view fragmentShader)
 {
+  Shader shader = Shader::New(vertexShader, fragmentShader, Shader::Hint::NONE, Scripting::GetLinearEnumerationName<ShaderType>(type, VISUAL_SHADER_TYPE_TABLE, VISUAL_SHADER_TYPE_TABLE_COUNT));
   mShader[type] = shader;
+  return shader;
 }
 
 Geometry VisualFactoryCache::CreateQuadGeometry()
@@ -131,16 +147,6 @@ NPatchLoader& VisualFactoryCache::GetNPatchLoader()
   return mNPatchLoader;
 }
 
-SvgRasterizeThread* VisualFactoryCache::GetSVGRasterizationThread()
-{
-  if(!mSvgRasterizeThread)
-  {
-    mSvgRasterizeThread = new SvgRasterizeThread();
-    mSvgRasterizeThread->Start();
-  }
-  return mSvgRasterizeThread;
-}
-
 VectorAnimationManager& VisualFactoryCache::GetVectorAnimationManager()
 {
   if(!mVectorAnimationManager)
@@ -241,11 +247,16 @@ void VisualFactoryCache::SetPreMultiplyOnLoad(bool preMultiply)
   mPreMultiplyOnLoad = preMultiply;
 }
 
-bool VisualFactoryCache::GetPreMultiplyOnLoad()
+bool VisualFactoryCache::GetPreMultiplyOnLoad() const
 {
   return mPreMultiplyOnLoad;
 }
 
+bool VisualFactoryCache::GetLoadYuvPlanes() const
+{
+  return mLoadYuvPlanes;
+}
+
 void VisualFactoryCache::SetBrokenImageUrl(std::string& defaultBrokenUrl, const std::vector<std::string>& brokenImageUrlList)
 {
   mUseDefaultBrokenImageOnly = false;
@@ -266,8 +277,8 @@ VisualUrl::Type VisualFactoryCache::GetBrokenImageVisualType(int index)
 
 Geometry VisualFactoryCache::GetNPatchGeometry(int index)
 {
-  Geometry          geometry;
-  const NPatchData* data;
+  Geometry      geometry;
+  NPatchDataPtr data;
   if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
   {
     if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
@@ -300,8 +311,8 @@ Geometry VisualFactoryCache::GetNPatchGeometry(int index)
 
 Shader VisualFactoryCache::GetNPatchShader(int index)
 {
-  Shader            shader;
-  const NPatchData* data;
+  Shader        shader;
+  NPatchDataPtr data;
   // 0 is either no data (load failed?) or no stretch regions on image
   // for both cases we use the default shader
   NPatchUtility::StretchRanges::SizeType xStretchCount = 0;
@@ -319,32 +330,33 @@ Shader VisualFactoryCache::GetNPatchShader(int index)
     shader = GetShader(VisualFactoryCache::NINE_PATCH_SHADER);
     if(DALI_UNLIKELY(!shader))
     {
-      shader = Shader::New(SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, SHADER_NPATCH_VISUAL_SHADER_FRAG);
-
       // Only cache vanilla 9 patch shaders
-      SaveShader(VisualFactoryCache::NINE_PATCH_SHADER, shader);
+      shader = GenerateAndSaveShader(VisualFactoryCache::NINE_PATCH_SHADER, SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, SHADER_NPATCH_VISUAL_SHADER_FRAG);
     }
   }
   else if(xStretchCount > 0 || yStretchCount > 0)
   {
+    std::stringstream shaderName;
+    shaderName << "N_PATCH_" << xStretchCount << "x" << yStretchCount;
+
     std::stringstream vertexShader;
     vertexShader << "#define FACTOR_SIZE_X " << xStretchCount + 2 << "\n"
                  << "#define FACTOR_SIZE_Y " << yStretchCount + 2 << "\n"
                  << SHADER_NPATCH_VISUAL_SHADER_VERT;
-    shader = Shader::New(vertexShader.str(), SHADER_NPATCH_VISUAL_SHADER_FRAG);
+    shader = Shader::New(vertexShader.str(), SHADER_NPATCH_VISUAL_SHADER_FRAG, Dali::Shader::Hint::NONE, shaderName.str());
   }
   return shader;
 }
 
 void VisualFactoryCache::ApplyTextureAndUniforms(Renderer& renderer, int index)
 {
-  const NPatchData* data;
-  TextureSet        textureSet;
+  NPatchDataPtr data;
+  TextureSet    textureSet;
   if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
   {
     textureSet                               = data->GetTextures();
     mBrokenImageInfoContainer[index].texture = textureSet.GetTexture(0);
-    NPatchHelper::ApplyTextureAndUniforms(renderer, data);
+    NPatchHelper::ApplyTextureAndUniforms(renderer, data.Get());
     renderer.SetTextures(textureSet);
   }
 }
@@ -368,8 +380,8 @@ void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vec
         mBrokenImageInfoContainer[index].visualType = visualUrl.GetType();
         if(mBrokenImageInfoContainer[index].visualType == VisualUrl::Type::N_PATCH)
         {
-          const NPatchData* data;
-          Rect<int>         border;
+          NPatchDataPtr data;
+          Rect<int>     border;
           mBrokenImageInfoContainer[index].npatchId = mNPatchLoader.Load(mTextureManager, NULL, mBrokenImageInfoContainer[index].url, border, mPreMultiplyOnLoad, true);
           if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
           {
@@ -428,11 +440,8 @@ void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vec
       Shader   shader   = GetShader(IMAGE_SHADER);
       if(!shader)
       {
-        std::string vertexShader   = std::string(Dali::Shader::GetVertexShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_VERT.data());
-        std::string fragmentShader = std::string(Dali::Shader::GetFragmentShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_FRAG.data());
-        shader                     = Shader::New(vertexShader, fragmentShader);
+        shader = GenerateAndSaveShader(IMAGE_SHADER, Dali::Shader::GetVertexShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_FRAG.data());
         shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
-        SaveShader(IMAGE_SHADER, shader);
       }
       renderer.SetGeometry(geometry);
       renderer.SetShader(shader);
@@ -448,7 +457,7 @@ int32_t VisualFactoryCache::GetProperBrokenImageIndex(const Vector2& size)
 {
   // Sets the default broken type
   int32_t returnIndex = 0;
-  if((size.width == 0 || size.height == 0) || mUseDefaultBrokenImageOnly)
+  if(Dali::EqualsZero(size.width) || Dali::EqualsZero(size.height) || mUseDefaultBrokenImageOnly)
   {
     // To do : Need to add observer about size
     return returnIndex;