Use shared uniform blocks for visual

Let we use shared uniform blocks for VisualRenderer if we use Visual by visual factory.

If we don't change default value, we can use shared visual properties.

Change-Id: Icc3dc9c955c2e350f1922b9c76e75cc8e2561986
Signed-off-by: Eunki, Hong <eunkiki.hong@samsung.com>

diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-Visuals-internal.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-Visuals-internal.cpp
index 40ae0b80f21b274353c898a7e825807dd9b72e9b..3472f09cf492b36f48b41828cf9b34d1467e437d 100644 (file)
--- a/automated-tests/src/dali-toolkit-internal/utc-Dali-Visuals-internal.cpp
+++ b/automated-tests/src/dali-toolkit-internal/utc-Dali-Visuals-internal.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -384,10 +384,11 @@ int UtcDaliVisualUpdateBrokenImageRenderer(void)
   // Set default broken image
   factoryCache->SetBrokenImageUrl(defaultBrokenImageUrl, std::vector<std::string>());
 
-  //Created dummy renderer
+  //Created dummy visual renderer
   Geometry geometry = factoryCache->GetGeometry(Toolkit::Internal::VisualFactoryCache::QUAD_GEOMETRY);
   Shader   shader   = Shader::New("foo", "bar");
-  Renderer renderer = Renderer::New(geometry, shader);
+
+  VisualRenderer renderer = VisualRenderer::New(geometry, shader);
 
   DALI_TEST_CHECK(renderer);
 

diff --git a/dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.cpp b/dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.cpp
index 93fbcbcdb44f73c5e5a96943e693350515513c39..2b6a69b692be8875d9e546b1614619d75b5edb43 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.cpp
+++ b/dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.cpp
@@ -463,7 +463,19 @@ void AnimatedGradientVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
+  }
+}
+
+void AnimatedGradientVisual::UpdateShader()
+{
+  if(mImpl->mRenderer)
+  {
+    Shader shader = GetOrCreateShader();
+    mImpl->mRenderer.SetShader(shader);
   }
 }
 
@@ -597,61 +609,65 @@ Shader AnimatedGradientVisual::GetOrCreateShader()
 
   VisualFactoryCache::ShaderType shaderType = GetShaderType(mGradientType, mUnitType, mSpreadType);
 
-  std::string tagUnit;
-  std::string tagGrad;
-  std::string tagSpread;
-  switch(mUnitType)
-  {
-    case Toolkit::DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX:
-    {
-      tagUnit = "UNIT_TYPE_BOUNDING_BOX";
-      break;
-    }
-    case Toolkit::DevelAnimatedGradientVisual::UnitType::USER_SPACE:
-    {
-      tagUnit = "UNIT_TYPE_USER";
-      break;
-    }
-  }
-  switch(mGradientType)
-  {
-    case Toolkit::DevelAnimatedGradientVisual::GradientType::LINEAR:
-    {
-      tagGrad = "GRADIENT_TYPE_LINEAR";
-      break;
-    }
-    case Toolkit::DevelAnimatedGradientVisual::GradientType::RADIAL:
-    {
-      tagGrad = "GRADIENT_TYPE_RADIAL";
-      break;
-    }
-  }
-  switch(mSpreadType)
+  shader = mFactoryCache.GetShader(shaderType, mImpl->mTransformMapUsingDefault);
+  if(!shader)
   {
-    case Toolkit::DevelAnimatedGradientVisual::SpreadType::REFLECT:
+    std::string tagUnit;
+    std::string tagGrad;
+    std::string tagSpread;
+    switch(mUnitType)
     {
-      tagSpread = "SPREAD_TYPE_REFLECT";
-      break;
+      case Toolkit::DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX:
+      {
+        tagUnit = "UNIT_TYPE_BOUNDING_BOX";
+        break;
+      }
+      case Toolkit::DevelAnimatedGradientVisual::UnitType::USER_SPACE:
+      {
+        tagUnit = "UNIT_TYPE_USER";
+        break;
+      }
     }
-    case Toolkit::DevelAnimatedGradientVisual::SpreadType::REPEAT:
+    switch(mGradientType)
     {
-      tagSpread = "SPREAD_TYPE_REPEAT";
-      break;
+      case Toolkit::DevelAnimatedGradientVisual::GradientType::LINEAR:
+      {
+        tagGrad = "GRADIENT_TYPE_LINEAR";
+        break;
+      }
+      case Toolkit::DevelAnimatedGradientVisual::GradientType::RADIAL:
+      {
+        tagGrad = "GRADIENT_TYPE_RADIAL";
+        break;
+      }
     }
-    case Toolkit::DevelAnimatedGradientVisual::SpreadType::CLAMP:
+    switch(mSpreadType)
     {
-      tagSpread = "SPREAD_TYPE_CLAMP";
-      break;
+      case Toolkit::DevelAnimatedGradientVisual::SpreadType::REFLECT:
+      {
+        tagSpread = "SPREAD_TYPE_REFLECT";
+        break;
+      }
+      case Toolkit::DevelAnimatedGradientVisual::SpreadType::REPEAT:
+      {
+        tagSpread = "SPREAD_TYPE_REPEAT";
+        break;
+      }
+      case Toolkit::DevelAnimatedGradientVisual::SpreadType::CLAMP:
+      {
+        tagSpread = "SPREAD_TYPE_CLAMP";
+        break;
+      }
     }
-  }
 
-  std::string vert;
-  std::string frag;
+    std::string vert;
+    std::string frag;
 
-  vert = "#define " + tagUnit + "\n" + SHADER_ANIMATED_GRADIENT_VISUAL_SHADER_VERT.data();
-  frag = "#define " + tagGrad + "\n" + "#define " + tagSpread + "\n" + SHADER_ANIMATED_GRADIENT_VISUAL_SHADER_FRAG.data();
+    vert = "#define " + tagUnit + "\n" + SHADER_ANIMATED_GRADIENT_VISUAL_SHADER_VERT.data();
+    frag = "#define " + tagGrad + "\n" + "#define " + tagSpread + "\n" + SHADER_ANIMATED_GRADIENT_VISUAL_SHADER_FRAG.data();
 
-  shader = mFactoryCache.GenerateAndSaveShader(shaderType, vert, frag);
+    shader = mFactoryCache.GenerateAndSaveShader(shaderType, vert, frag, mImpl->mTransformMapUsingDefault);
+  }
   return shader;
 }
 
@@ -672,7 +688,7 @@ void AnimatedGradientVisual::OnInitialize()
   mImpl->mRenderer.RegisterUniqueProperty(UNIFORM_OFFSET_NAME, GetStartValue(mValueMap, Toolkit::DevelAnimatedGradientVisual::Property::OFFSET, OFFSET_NAME));
 
   //Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 }
 
 } //namespace Internal

diff --git a/dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.h b/dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.h
index d16099fb612349682aaf45d03c34402837498938..157c7a37de6ce0f70801519af8d1f311ca2dec02 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.h
+++ b/dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.h
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_INTERNAL_ANIMATED_GRADIENT_VISUAL_H
 
 /*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -199,11 +199,6 @@ protected: //from Visual
    */
   void DoSetProperties(const Property::Map& propertyMap) override;
 
-  /**
-   * @copydoc Visual::Base::OnSetTransform
-   */
-  void OnSetTransform() override;
-
   /**
    * @copydoc Visual::Base::DoSetOnScene
    */
@@ -214,6 +209,16 @@ protected: //from Visual
    */
   void DoSetOffScene(Actor& actor) override;
 
+  /**
+   * @copydoc Visual::Base::OnSetTransform
+   */
+  void OnSetTransform() override;
+
+  /**
+   * @copydoc Visual::Base::UpdateShader
+   */
+  void UpdateShader() override;
+
 private:
   /**
    * @brief Initialize the default value of properies.

diff --git a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp
index bcd3e9308be8c1db1e2cab2b0a539f5c7a710e79..c27c5a348a836fd962923f97b5094f9a9fb1bd0f 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp
+++ b/dali-toolkit/internal/visuals/animated-image/animated-image-visual.cpp
@@ -1033,7 +1033,10 @@ void AnimatedImageVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
   }
 }
 
@@ -1060,6 +1063,11 @@ Shader AnimatedImageVisual::GenerateShader() const
     // Most of image visual shader user (like svg, animated vector image visual) use pre-multiplied alpha.
     // If the visual dont want to using pre-multiplied alpha, it should be set as 0.0f as renderer side.
     shader.RegisterProperty(PREMULTIPLIED_ALPHA, ALPHA_VALUE_PREMULTIPLIED);
+
+    if(mImpl->mRenderer)
+    {
+      mImpl->mRenderer.RegisterVisualTransformUniform();
+    }
   }
   else
   {
@@ -1072,7 +1080,8 @@ Shader AnimatedImageVisual::GenerateShader() const
         .ApplyDefaultTextureWrapMode(defaultWrapMode)
         .EnableRoundedCorner(IsRoundedCornerRequired(), IsSquircleCornerRequired())
         .EnableBorderline(IsBorderlineRequired())
-        .EnableAlphaMaskingOnRendering(requiredAlphaMaskingOnRendering));
+        .EnableAlphaMaskingOnRendering(requiredAlphaMaskingOnRendering)
+        .UseDefaultTransform(mImpl->mTransformMapUsingDefault));
   }
   return shader;
 }
@@ -1109,7 +1118,11 @@ void AnimatedImageVisual::OnInitialize()
   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
 
   // Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  if(mImpl->mCustomShader)
+  {
+    mImpl->mRenderer.RegisterVisualTransformUniform();
+  }
 
   if(!defaultWrapMode) // custom wrap mode
   {

diff --git a/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp b/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp
index 354a63ec70ffd4ff88e7816ee8d32f3e38ab517a..8ce304b62b72f3fa62e0743a6398040bffa4c0cd 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp
+++ b/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp
@@ -482,7 +482,11 @@ void AnimatedVectorImageVisual::OnInitialize(void)
   mImpl->mRenderer.SetTextures(textureSet);
 
   // Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  if(mImpl->mCustomShader)
+  {
+    mImpl->mRenderer.RegisterVisualTransformUniform();
+  }
 
   mVectorAnimationTask->SetRenderer(mImpl->mRenderer);
 }
@@ -558,7 +562,10 @@ void AnimatedVectorImageVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
   }
 
   if(IsOnScene())
@@ -929,6 +936,11 @@ Shader AnimatedVectorImageVisual::GenerateShader() const
     // Most of image visual shader user (like svg, animated vector image visual) use pre-multiplied alpha.
     // If the visual dont want to using pre-multiplied alpha, it should be set as 0.0f as renderer side.
     shader.RegisterProperty(PREMULTIPLIED_ALPHA, ALPHA_VALUE_PREMULTIPLIED);
+
+    if(mImpl->mRenderer)
+    {
+      mImpl->mRenderer.RegisterVisualTransformUniform();
+    }
   }
   else
   {
@@ -937,7 +949,8 @@ Shader AnimatedVectorImageVisual::GenerateShader() const
       ImageVisualShaderFeature::FeatureBuilder()
         .EnableRoundedCorner(IsRoundedCornerRequired(), IsSquircleCornerRequired())
         .EnableBorderline(IsBorderlineRequired())
-        .SetTextureForFragmentShaderCheck(mUseNativeImage ? mImpl->mRenderer.GetTextures().GetTexture(0) : Dali::Texture()));
+        .SetTextureForFragmentShaderCheck(mUseNativeImage ? mImpl->mRenderer.GetTextures().GetTexture(0) : Dali::Texture())
+        .UseDefaultTransform(mImpl->mTransformMapUsingDefault));
   }
   return shader;
 }

diff --git a/dali-toolkit/internal/visuals/arc/arc-visual.cpp b/dali-toolkit/internal/visuals/arc/arc-visual.cpp
index e8c4e0264c2c052aac562bfc011d945801ab88d8..02b05d3e150310e3a316ab29e9727d7a6f406c48 100644 (file)
--- a/dali-toolkit/internal/visuals/arc/arc-visual.cpp
+++ b/dali-toolkit/internal/visuals/arc/arc-visual.cpp
@@ -189,7 +189,7 @@ void ArcVisual::OnSetTransform()
 
     if(mImpl->mTransformMapChanged)
     {
-      mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+      mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
     }
   }
 }
@@ -201,18 +201,18 @@ void ArcVisual::OnInitialize()
   Shader shader;
   if(mCapType == DevelArcVisual::Cap::BUTT)
   {
-    shader = mFactoryCache.GetShader(VisualFactoryCache::ARC_BUTT_CAP_SHADER);
+    shader = mFactoryCache.GetShader(VisualFactoryCache::ARC_BUTT_CAP_SHADER, mImpl->mTransformMapUsingDefault);
     if(!shader)
     {
-      shader = mFactoryCache.GenerateAndSaveShader(VisualFactoryCache::ARC_BUTT_CAP_SHADER, Dali::Shader::GetVertexShaderPrefix() + SHADER_ARC_VISUAL_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_ARC_VISUAL_BUTT_CAP_SHADER_FRAG.data());
+      shader = mFactoryCache.GenerateAndSaveShader(VisualFactoryCache::ARC_BUTT_CAP_SHADER, Dali::Shader::GetVertexShaderPrefix() + SHADER_ARC_VISUAL_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_ARC_VISUAL_BUTT_CAP_SHADER_FRAG.data(), mImpl->mTransformMapUsingDefault);
     }
   }
   else
   {
-    shader = mFactoryCache.GetShader(VisualFactoryCache::ARC_ROUND_CAP_SHADER);
+    shader = mFactoryCache.GetShader(VisualFactoryCache::ARC_ROUND_CAP_SHADER, mImpl->mTransformMapUsingDefault);
     if(!shader)
     {
-      shader = mFactoryCache.GenerateAndSaveShader(VisualFactoryCache::ARC_ROUND_CAP_SHADER, Dali::Shader::GetVertexShaderPrefix() + SHADER_ARC_VISUAL_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_ARC_VISUAL_ROUND_CAP_SHADER_FRAG.data());
+      shader = mFactoryCache.GenerateAndSaveShader(VisualFactoryCache::ARC_ROUND_CAP_SHADER, Dali::Shader::GetVertexShaderPrefix() + SHADER_ARC_VISUAL_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_ARC_VISUAL_ROUND_CAP_SHADER_FRAG.data(), mImpl->mTransformMapUsingDefault);
     }
   }
 
@@ -228,7 +228,7 @@ void ArcVisual::OnInitialize()
   mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
 
   // Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 }
 
 } // namespace Internal

diff --git a/dali-toolkit/internal/visuals/border/border-visual.cpp b/dali-toolkit/internal/visuals/border/border-visual.cpp
index 943a91719fd9c043b10652e515e3da5658cee01d..87b9245d4170c5047fa934494b8a3b7c77819691 100644 (file)
--- a/dali-toolkit/internal/visuals/border/border-visual.cpp
+++ b/dali-toolkit/internal/visuals/border/border-visual.cpp
@@ -166,7 +166,10 @@ void BorderVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
   }
 }
 
@@ -184,7 +187,7 @@ void BorderVisual::OnInitialize()
   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
 
   //Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 }
 
 Shader BorderVisual::GetBorderShader()
@@ -192,18 +195,18 @@ Shader BorderVisual::GetBorderShader()
   Shader shader;
   if(mAntiAliasing)
   {
-    shader = mFactoryCache.GetShader(VisualFactoryCache::BORDER_SHADER_ANTI_ALIASING);
+    shader = mFactoryCache.GetShader(VisualFactoryCache::BORDER_SHADER_ANTI_ALIASING, mImpl->mTransformMapUsingDefault);
     if(!shader)
     {
-      shader = mFactoryCache.GenerateAndSaveShader(VisualFactoryCache::BORDER_SHADER_ANTI_ALIASING, Dali::Shader::GetVertexShaderPrefix() + SHADER_BORDER_VISUAL_ANTI_ALIASING_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_BORDER_VISUAL_ANTI_ALIASING_SHADER_FRAG.data());
+      shader = mFactoryCache.GenerateAndSaveShader(VisualFactoryCache::BORDER_SHADER_ANTI_ALIASING, Dali::Shader::GetVertexShaderPrefix() + SHADER_BORDER_VISUAL_ANTI_ALIASING_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_BORDER_VISUAL_ANTI_ALIASING_SHADER_FRAG.data(), mImpl->mTransformMapUsingDefault);
     }
   }
   else
   {
-    shader = mFactoryCache.GetShader(VisualFactoryCache::BORDER_SHADER);
+    shader = mFactoryCache.GetShader(VisualFactoryCache::BORDER_SHADER, mImpl->mTransformMapUsingDefault);
     if(!shader)
     {
-      shader = mFactoryCache.GenerateAndSaveShader(VisualFactoryCache::BORDER_SHADER, Dali::Shader::GetVertexShaderPrefix() + SHADER_BORDER_VISUAL_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_BORDER_VISUAL_SHADER_FRAG.data());
+      shader = mFactoryCache.GenerateAndSaveShader(VisualFactoryCache::BORDER_SHADER, Dali::Shader::GetVertexShaderPrefix() + SHADER_BORDER_VISUAL_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_BORDER_VISUAL_SHADER_FRAG.data(), mImpl->mTransformMapUsingDefault);
     }
   }
 

diff --git a/dali-toolkit/internal/visuals/color/color-visual-shader-factory.cpp b/dali-toolkit/internal/visuals/color/color-visual-shader-factory.cpp
index 1f29c3c0126c0015641392e01366990b2ffcdffe..f6bc67b9fde4b8e29e1e9217417a41e2f9552b01 100644 (file)
--- a/dali-toolkit/internal/visuals/color/color-visual-shader-factory.cpp
+++ b/dali-toolkit/internal/visuals/color/color-visual-shader-factory.cpp
@@ -94,7 +94,8 @@ FeatureBuilder::FeatureBuilder()
 : mColorRoundCorner(RoundedCorner::DISABLED),
   mColorBorderline(Borderline::DISABLED),
   mColorBlur(Blur::DISABLED),
-  mColorCutout(Cutout::DISABLED)
+  mColorCutout(Cutout::DISABLED),
+  mUseDefaultTransform(true)
 {
 }
 
@@ -122,6 +123,12 @@ FeatureBuilder& FeatureBuilder::EnableCutout(bool enableCutout)
   return *this;
 }
 
+FeatureBuilder& FeatureBuilder::UseDefaultTransform(bool useDefaultTransform)
+{
+  mUseDefaultTransform = useDefaultTransform;
+  return *this;
+}
+
 VisualFactoryCache::ShaderType FeatureBuilder::GetShaderType() const
 {
   VisualFactoryCache::ShaderType shaderType     = VisualFactoryCache::COLOR_SHADER;
@@ -207,6 +214,11 @@ void FeatureBuilder::GetFragmentShaderPrefixList(std::string& fragmentShaderPref
   }
 }
 
+bool FeatureBuilder::IsDefaultTransformUsed() const
+{
+  return mUseDefaultTransform;
+}
+
 } // namespace ColorVisualShaderFeature
 
 ColorVisualShaderFactory::ColorVisualShaderFactory()
@@ -221,7 +233,7 @@ Shader ColorVisualShaderFactory::GetShader(VisualFactoryCache& factoryCache, con
 {
   Shader                         shader;
   VisualFactoryCache::ShaderType shaderType = featureBuilder.GetShaderType();
-  shader                                    = factoryCache.GetShader(shaderType);
+  shader                                    = factoryCache.GetShader(shaderType, featureBuilder.IsDefaultTransformUsed());
 
   if(!shader)
   {
@@ -233,7 +245,7 @@ Shader ColorVisualShaderFactory::GetShader(VisualFactoryCache& factoryCache, con
     std::string vertexShader   = std::string(Dali::Shader::GetVertexShaderPrefix() + vertexShaderPrefixList + SHADER_COLOR_VISUAL_SHADER_VERT.data());
     std::string fragmentShader = std::string(Dali::Shader::GetFragmentShaderPrefix() + fragmentShaderPrefixList + SHADER_COLOR_VISUAL_SHADER_FRAG.data());
 
-    shader = factoryCache.GenerateAndSaveShader(shaderType, vertexShader, fragmentShader);
+    shader = factoryCache.GenerateAndSaveShader(shaderType, vertexShader, fragmentShader, featureBuilder.IsDefaultTransformUsed());
   }
   return shader;
 }

diff --git a/dali-toolkit/internal/visuals/color/color-visual-shader-factory.h b/dali-toolkit/internal/visuals/color/color-visual-shader-factory.h
index 81b56f46f89100d8533a0874c6518685462ad6a0..7f14287a17cd4de1c299d185e57f84204c9580fc 100644 (file)
--- a/dali-toolkit/internal/visuals/color/color-visual-shader-factory.h
+++ b/dali-toolkit/internal/visuals/color/color-visual-shader-factory.h
@@ -90,16 +90,20 @@ public:
   FeatureBuilder& EnableBorderLine(bool enableBorderLine);
   FeatureBuilder& EnableBlur(bool enableBlur);
   FeatureBuilder& EnableCutout(bool enableCutout);
+  FeatureBuilder& UseDefaultTransform(bool useDefaultTransform);
 
   VisualFactoryCache::ShaderType GetShaderType() const;
   void                           GetVertexShaderPrefixList(std::string& vertexShaderPrefixList) const;
   void                           GetFragmentShaderPrefixList(std::string& fragmentShaderPrefixList) const;
 
+  bool IsDefaultTransformUsed() const;
+
 private:
   RoundedCorner::Type mColorRoundCorner : 3; ///< Whether use rounded corner, or not. default as RoundedCorner::DISABLED
   Borderline::Type    mColorBorderline : 2;  ///< Whether use border line, or not. default as Borderline::DISABLED
   Blur::Type          mColorBlur : 2;        ///< Whether use blur, or not. default as Blur::DISABLED
   Cutout::Type        mColorCutout : 2;      ///< Whether use cutout, or not. default as Cutout::DISABLED
+  bool                mUseDefaultTransform : 1;
 };
 } // namespace ColorVisualShaderFeature
 

diff --git a/dali-toolkit/internal/visuals/color/color-visual.cpp b/dali-toolkit/internal/visuals/color/color-visual.cpp
index 3927dd38b3528e639b6620a95fa5bf2b7d469af0..ac8419e437f513abc7c2df5f63cb74afa5957067 100644 (file)
--- a/dali-toolkit/internal/visuals/color/color-visual.cpp
+++ b/dali-toolkit/internal/visuals/color/color-visual.cpp
@@ -20,6 +20,7 @@
 
 // EXTERNAL INCLUDES
 #include <dali/devel-api/rendering/renderer-devel.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
 #include <dali/integration-api/debug.h>
 #include <dali/public-api/rendering/decorated-visual-renderer.h>
 
@@ -208,7 +209,10 @@ void ColorVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
   }
 }
 
@@ -246,7 +250,7 @@ void ColorVisual::OnInitialize()
   }
 
   // Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 }
 
 Shader ColorVisual::GenerateShader() const
@@ -257,7 +261,8 @@ Shader ColorVisual::GenerateShader() const
       .EnableBlur(IsBlurRequired())
       .EnableBorderLine(IsBorderlineRequired())
       .EnableRoundCorner(IsRoundedCornerRequired(), IsSquircleCornerRequired())
-      .EnableCutout(IsCutoutRequired()));
+      .EnableCutout(IsCutoutRequired())
+      .UseDefaultTransform(mImpl->mTransformMapUsingDefault));
 
   return shader;
 }

diff --git a/dali-toolkit/internal/visuals/gradient/gradient-visual.cpp b/dali-toolkit/internal/visuals/gradient/gradient-visual.cpp
index 07be72ecf546cdae8467e35c7a3b6b7b6bb61614..abd79628a6aeb5f2eef5fbbc7e8ec0f00bf99cbc 100644 (file)
--- a/dali-toolkit/internal/visuals/gradient/gradient-visual.cpp
+++ b/dali-toolkit/internal/visuals/gradient/gradient-visual.cpp
@@ -181,7 +181,10 @@ void GradientVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
   }
 }
 
@@ -292,7 +295,7 @@ void GradientVisual::OnInitialize()
   mImpl->mRenderer.RegisterUniqueProperty(UNIFORM_TEXTURE_COORDINATE_SCALE_FACTOR_NAME, (textureSize - 1.0f) / textureSize);
 
   // Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 }
 
 bool GradientVisual::NewGradient(Type gradientType, const Property::Map& propertyMap)
@@ -409,7 +412,7 @@ Shader GradientVisual::GenerateShader() const
   DALI_ASSERT_DEBUG(shaderTypeFlag < SHADER_TYPE_TABLE_COUNT && "Invalid gradient shader type generated!");
 
   VisualFactoryCache::ShaderType shaderType = SHADER_TYPE_TABLE[shaderTypeFlag];
-  Shader                         shader     = mFactoryCache.GetShader(shaderType);
+  Shader                         shader     = mFactoryCache.GetShader(shaderType, mImpl->mTransformMapUsingDefault);
   if(!shader)
   {
     std::string vertexShaderPrefixList;
@@ -440,7 +443,8 @@ Shader GradientVisual::GenerateShader() const
 
     shader = mFactoryCache.GenerateAndSaveShader(shaderType,
                                                  Dali::Shader::GetVertexShaderPrefix() + vertexShaderPrefixList + SHADER_GRADIENT_VISUAL_SHADER_VERT.data(),
-                                                 Dali::Shader::GetFragmentShaderPrefix() + fragmentShaderPrefixList + SHADER_GRADIENT_VISUAL_SHADER_FRAG.data());
+                                                 Dali::Shader::GetFragmentShaderPrefix() + fragmentShaderPrefixList + SHADER_GRADIENT_VISUAL_SHADER_FRAG.data(),
+                                                 mImpl->mTransformMapUsingDefault);
   }
 
   return shader;

diff --git a/dali-toolkit/internal/visuals/gradient/gradient-visual.h b/dali-toolkit/internal/visuals/gradient/gradient-visual.h
index 9a471d464c6badd76a4a416ae36389aec4a92607..05c90be4f43a8f085a169803e6f7911de750d434 100644 (file)
--- a/dali-toolkit/internal/visuals/gradient/gradient-visual.h
+++ b/dali-toolkit/internal/visuals/gradient/gradient-visual.h
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_INTERNAL_GRADIENT_VISUAL_H
 
 /*
- * 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.

diff --git a/dali-toolkit/internal/visuals/image/image-visual-shader-factory.cpp b/dali-toolkit/internal/visuals/image/image-visual-shader-factory.cpp
index 6917ac446efc848864f37bbfdb5705c5527a2963..39ced7376c405f5ec1c7af30ca36b1213b2db00f 100644 (file)
--- a/dali-toolkit/internal/visuals/image/image-visual-shader-factory.cpp
+++ b/dali-toolkit/internal/visuals/image/image-visual-shader-factory.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -96,7 +96,7 @@ Shader ImageVisualShaderFactory::GetShader(VisualFactoryCache& factoryCache, con
     shaderType = static_cast<VisualFactoryCache::ShaderType>(static_cast<int>(shaderType) + NATIVE_SHADER_TYPE_OFFSET);
   }
 
-  shader = factoryCache.GetShader(shaderType);
+  shader = factoryCache.GetShader(shaderType, featureBuilder.IsDefaultTransformUsed());
   if(shader)
   {
     return shader;
@@ -135,7 +135,7 @@ Shader ImageVisualShaderFactory::GetShader(VisualFactoryCache& factoryCache, con
       if(mFragmentShaderNeedChange == ImageVisualShaderFeature::ChangeFragmentShader::DONT_CHANGE)
       {
         shaderType = static_cast<VisualFactoryCache::ShaderType>(static_cast<int>(shaderType) - NATIVE_SHADER_TYPE_OFFSET);
-        shader     = factoryCache.GetShader(shaderType);
+        shader     = factoryCache.GetShader(shaderType, featureBuilder.IsDefaultTransformUsed());
       }
     }
   }
@@ -145,7 +145,7 @@ Shader ImageVisualShaderFactory::GetShader(VisualFactoryCache& factoryCache, con
     return shader;
   }
 
-  shader = factoryCache.GenerateAndSaveShader(shaderType, vertexShader, fragmentShader);
+  shader = factoryCache.GenerateAndSaveShader(shaderType, vertexShader, fragmentShader, featureBuilder.IsDefaultTransformUsed());
 
   shader.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT +
                                  ((featureBuilder.IsEnabledAlphaMaskingOnRendering() ? 1 : 0)));

diff --git a/dali-toolkit/internal/visuals/image/image-visual-shader-feature-builder.cpp b/dali-toolkit/internal/visuals/image/image-visual-shader-feature-builder.cpp
index ff04c8ee01eda050b3188b2a7cd69efa7c992799..8f16104900de29b6249c6caeb45365a9a9b29658 100644 (file)
--- a/dali-toolkit/internal/visuals/image/image-visual-shader-feature-builder.cpp
+++ b/dali-toolkit/internal/visuals/image/image-visual-shader-feature-builder.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -77,6 +77,7 @@ FeatureBuilder::FeatureBuilder()
   mBorderline(Borderline::DISABLED),
   mAlphaMaskingOnRendering(AlphaMaskingOnRendering::DISABLED),
   mColorConversion(ColorConversion::DONT_NEED),
+  mUseDefaultTransform(true),
   mTexture()
 {
 }
@@ -123,6 +124,12 @@ FeatureBuilder& FeatureBuilder::EnableYuvToRgb(bool enableYuvToRgb, bool enableU
   return *this;
 }
 
+FeatureBuilder& FeatureBuilder::UseDefaultTransform(bool useDefaultTransform)
+{
+  mUseDefaultTransform = useDefaultTransform;
+  return *this;
+}
+
 VisualFactoryCache::ShaderType FeatureBuilder::GetShaderType() const
 {
   VisualFactoryCache::ShaderType shaderType = VisualFactoryCache::IMAGE_SHADER;
@@ -254,6 +261,11 @@ bool FeatureBuilder::IsEnabledAlphaMaskingOnRendering() const
   return mAlphaMaskingOnRendering == AlphaMaskingOnRendering::ENABLED;
 }
 
+bool FeatureBuilder::IsDefaultTransformUsed() const
+{
+  return mUseDefaultTransform;
+}
+
 } // namespace ImageVisualShaderFeature
 
 } // namespace Internal

diff --git a/dali-toolkit/internal/visuals/image/image-visual-shader-feature-builder.h b/dali-toolkit/internal/visuals/image/image-visual-shader-feature-builder.h
index 97d493b9c3082833cf6fbf3eeb81a6ba7652b157..60bf42d267c414779a4b489a0164caf418ee4a23 100644 (file)
--- a/dali-toolkit/internal/visuals/image/image-visual-shader-feature-builder.h
+++ b/dali-toolkit/internal/visuals/image/image-visual-shader-feature-builder.h
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_IMAGE_VISUAL_SHADER_FEATURE_BUILDER_H
 
 /*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -144,6 +144,8 @@ public:
 
   FeatureBuilder& EnableYuvToRgb(bool enableYuvToRgb, bool enableUnifiedYuvAndRgb = false);
 
+  FeatureBuilder& UseDefaultTransform(bool useDefaultTransform);
+
   VisualFactoryCache::ShaderType GetShaderType() const;
 
   ChangeFragmentShader::Type NeedToChangeFragmentShader() const;
@@ -154,6 +156,7 @@ public:
   Dali::Texture GetTexture() const;
 
   bool IsEnabledAlphaMaskingOnRendering() const;
+  bool IsDefaultTransformUsed() const;
 
 private:
   TextureAtlas::Type            mTextureAtlas : 2;            ///< Whether use texture with atlas, or not. default as TextureAtlas::DISABLED
@@ -162,7 +165,8 @@ private:
   Borderline::Type              mBorderline : 2;              ///< Whether use borderline, or not. default as Borderline::DISABLED
   AlphaMaskingOnRendering::Type mAlphaMaskingOnRendering : 2; ///< Whether use runtime alpha masking, or not. default as AlphaMaskingOnRendering::DISABLED
   ColorConversion::Type         mColorConversion : 2;         ///< Whether the color format conversion is needed or not
-  Dali::Texture                 mTexture;                     ///< Texture to check whether we need to change fragment shader or not
+  bool                          mUseDefaultTransform : 1;
+  Dali::Texture                 mTexture; ///< Texture to check whether we need to change fragment shader or not
 };
 
 } // namespace ImageVisualShaderFeature

diff --git a/dali-toolkit/internal/visuals/image/image-visual.cpp b/dali-toolkit/internal/visuals/image/image-visual.cpp
index e4363c518674cb6bcde2b90d07b34f5266fd717b..9b768a9c21f6b722da65103eaf430f98789e5508 100644 (file)
--- a/dali-toolkit/internal/visuals/image/image-visual.cpp
+++ b/dali-toolkit/internal/visuals/image/image-visual.cpp
@@ -682,7 +682,11 @@ void ImageVisual::OnInitialize()
   }
 
   //Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  if(mImpl->mCustomShader)
+  {
+    mImpl->mRenderer.RegisterVisualTransformUniform();
+  }
 
   EnablePreMultipliedAlpha(IsPreMultipliedAlphaEnabled());
 
@@ -1097,7 +1101,10 @@ void ImageVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
   }
 
   if(mUseSynchronousSizing)
@@ -1408,7 +1415,8 @@ Shader ImageVisual::GenerateShader() const
         .EnableBorderline(IsBorderlineRequired())
         .SetTextureForFragmentShaderCheck(useNativeImage ? mNativeTexture : Dali::Texture())
         .EnableAlphaMaskingOnRendering(requiredAlphaMaskingOnRendering)
-        .EnableYuvToRgb(mNeedYuvToRgb, mNeedUnifiedYuvAndRgb));
+        .EnableYuvToRgb(mNeedYuvToRgb, mNeedUnifiedYuvAndRgb)
+        .UseDefaultTransform(mImpl->mTransformMapUsingDefault));
   }
   else
   {
@@ -1464,6 +1472,11 @@ Shader ImageVisual::GenerateShader() const
     // Most of image visual shader user (like svg, animated vector image visual) use pre-multiplied alpha.
     // If the visual dont want to using pre-multiplied alpha, it should be set as 0.0f as renderer side.
     shader.RegisterProperty(PREMULTIPLIED_ALPHA, ALPHA_VALUE_PREMULTIPLIED);
+
+    if(mImpl->mRenderer)
+    {
+      mImpl->mRenderer.RegisterVisualTransformUniform();
+    }
   }
 
   return shader;

diff --git a/dali-toolkit/internal/visuals/mesh/mesh-visual.cpp b/dali-toolkit/internal/visuals/mesh/mesh-visual.cpp
index f02f6e914e9cbbc658473148c377a7661e2d2d99..dd2201c22faba5b70a3748d03d6a8435046970d7 100644 (file)
--- a/dali-toolkit/internal/visuals/mesh/mesh-visual.cpp
+++ b/dali-toolkit/internal/visuals/mesh/mesh-visual.cpp
@@ -24,6 +24,7 @@
 #include <dali/devel-api/common/stage.h>
 #include <dali/devel-api/scripting/enum-helper.h>
 #include <dali/devel-api/scripting/scripting.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
 #include <dali/integration-api/debug.h>
 
 //INTERNAL INCLUDES
@@ -237,7 +238,26 @@ void MeshVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
+  }
+}
+
+void MeshVisual::UpdateShader()
+{
+  if(mImpl->mRenderer)
+  {
+    if(!mImpl->mTransformMapUsingDefault)
+    {
+      // Unregister default uniform blocks if transform changed.
+      if(DALI_LIKELY(Dali::Adaptor::IsAvailable()) && mShader)
+      {
+        mFactoryCache.GetDefaultUniformBlock().DisconnectFromShader(mShader);
+      }
+      mImpl->mRenderer.RegisterVisualTransformUniform();
+    }
   }
 }
 
@@ -303,12 +323,16 @@ void MeshVisual::OnInitialize()
   }
 
   mImpl->mRenderer = VisualRenderer::New(mGeometry, mShader);
+  if(DALI_LIKELY(Dali::Adaptor::IsAvailable()) && mImpl->mTransformMapUsingDefault)
+  {
+    mFactoryCache.GetDefaultUniformBlock().ConnectToShader(mShader);
+  }
   mImpl->mRenderer.SetTextures(mTextureSet);
   mImpl->mRenderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::ON);
   mImpl->mRenderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON);
 
   //Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 }
 
 void MeshVisual::SupplyEmptyGeometry()

diff --git a/dali-toolkit/internal/visuals/mesh/mesh-visual.h b/dali-toolkit/internal/visuals/mesh/mesh-visual.h
index d4765e99fea3b630bb21a9a64ddb59af1ef22cb5..8158ca9e0724955e6a33a29edee3b7eff3a026c6 100644 (file)
--- a/dali-toolkit/internal/visuals/mesh/mesh-visual.h
+++ b/dali-toolkit/internal/visuals/mesh/mesh-visual.h
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_INTERNAL_MESH_VISUAL_H
 
 /*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -98,15 +98,20 @@ protected:
    */
   void DoSetProperties(const Property::Map& propertyMap) override;
 
+  /**
+   * @copydoc Visual::Base::DoSetOnScene
+   */
+  void DoSetOnScene(Actor& actor) override;
+
   /**
    * @copydoc Visual::Base::OnSetTransform
    */
   void OnSetTransform() override;
 
   /**
-   * @copydoc Visual::Base::DoSetOnScene
+   * @copydoc Visual::Base::UpdateShader
    */
-  void DoSetOnScene(Actor& actor) override;
+  void UpdateShader() override;
 
 private:
   /**

diff --git a/dali-toolkit/internal/visuals/npatch/npatch-visual.cpp b/dali-toolkit/internal/visuals/npatch/npatch-visual.cpp
index f5ec71128db74f4346969234ec81de409e55c7e9..68a65d87bebe7c1ae8b308d871733a58f8742b46 100644 (file)
--- a/dali-toolkit/internal/visuals/npatch/npatch-visual.cpp
+++ b/dali-toolkit/internal/visuals/npatch/npatch-visual.cpp
@@ -274,7 +274,19 @@ void NPatchVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
+  }
+}
+
+void NPatchVisual::UpdateShader()
+{
+  if(mImpl->mRenderer)
+  {
+    Shader shader = CreateShader();
+    mImpl->mRenderer.SetShader(shader);
   }
 }
 
@@ -371,7 +383,7 @@ void NPatchVisual::OnInitialize()
   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
 
   //Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 }
 
 Geometry NPatchVisual::CreateGeometry()
@@ -455,10 +467,10 @@ Shader NPatchVisual::CreateShader()
     if(DALI_LIKELY((xStretchCount == 1 && yStretchCount == 1) ||
                    (xStretchCount == 0 && yStretchCount == 0)))
     {
-      shader = mFactoryCache.GetShader(shaderType);
+      shader = mFactoryCache.GetShader(shaderType, mImpl->mTransformMapUsingDefault);
       if(DALI_UNLIKELY(!shader))
       {
-        shader = mFactoryCache.GenerateAndSaveShader(shaderType, SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, fragmentShader);
+        shader = mFactoryCache.GenerateAndSaveShader(shaderType, SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, fragmentShader, mImpl->mTransformMapUsingDefault);
       }
     }
     else if(xStretchCount > 0 || yStretchCount > 0)
@@ -472,6 +484,11 @@ Shader NPatchVisual::CreateShader()
                    << SHADER_NPATCH_VISUAL_SHADER_VERT;
 
       shader = Shader::New(vertexShader.str(), fragmentShader, Dali::Shader::Hint::NONE, shaderName.str());
+
+      if(DALI_LIKELY(mImpl->mRenderer))
+      {
+        mImpl->mRenderer.RegisterVisualTransformUniform();
+      }
     }
   }
   else
@@ -508,6 +525,11 @@ Shader NPatchVisual::CreateShader()
 
       shader = Shader::New(vertexShader.str(), fragmentShader, hints, shaderName.str());
     }
+
+    if(DALI_LIKELY(mImpl->mRenderer))
+    {
+      mImpl->mRenderer.RegisterVisualTransformUniform();
+    }
   }
 
   return shader;
@@ -555,7 +577,7 @@ void NPatchVisual::ApplyTextureAndUniforms()
   }
 
   // Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 }
 
 Geometry NPatchVisual::GetNinePatchGeometry(VisualFactoryCache::GeometryType subType)

diff --git a/dali-toolkit/internal/visuals/npatch/npatch-visual.h b/dali-toolkit/internal/visuals/npatch/npatch-visual.h
index efb29c27d856381267815a8f94228323da7fb26d..5776e8733c9e59bddd061d4e4263cb129dcebc7b 100644 (file)
--- a/dali-toolkit/internal/visuals/npatch/npatch-visual.h
+++ b/dali-toolkit/internal/visuals/npatch/npatch-visual.h
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_INTERNAL_N_PATCH_VISUAL_H
 
 /*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -142,6 +142,11 @@ protected:
    */
   void OnSetTransform() override;
 
+  /**
+   * @copydoc Visual::Base::UpdateShader
+   */
+  void UpdateShader() override;
+
 private:
   /**
    * Loads the NPatch image and the Auxiliary image if needed

diff --git a/dali-toolkit/internal/visuals/primitive/primitive-visual.cpp b/dali-toolkit/internal/visuals/primitive/primitive-visual.cpp
index 666846efe75fcbeda187289e9da6284209d822fb..52e4d8fd7f1db623ce10f22cc612d8b74ea653cb 100644 (file)
--- a/dali-toolkit/internal/visuals/primitive/primitive-visual.cpp
+++ b/dali-toolkit/internal/visuals/primitive/primitive-visual.cpp
@@ -22,6 +22,7 @@
 #include <dali/devel-api/common/stage.h>
 #include <dali/devel-api/scripting/enum-helper.h>
 #include <dali/devel-api/scripting/scripting.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
 #include <dali/integration-api/debug.h>
 #include <dali/public-api/common/constants.h>
 
@@ -363,7 +364,26 @@ void PrimitiveVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
+  }
+}
+
+void PrimitiveVisual::UpdateShader()
+{
+  if(mImpl->mRenderer)
+  {
+    if(!mImpl->mTransformMapUsingDefault)
+    {
+      // Unregister default uniform blocks if transform changed.
+      if(DALI_LIKELY(Dali::Adaptor::IsAvailable()) && mShader)
+      {
+        mFactoryCache.GetDefaultUniformBlock().DisconnectFromShader(mShader);
+      }
+      mImpl->mRenderer.RegisterVisualTransformUniform();
+    }
   }
 }
 
@@ -380,8 +400,12 @@ void PrimitiveVisual::OnInitialize()
   }
 
   mImpl->mRenderer = VisualRenderer::New(mGeometry, mShader);
+  if(mImpl->mTransformMapUsingDefault)
+  {
+    mFactoryCache.GetDefaultUniformBlock().ConnectToShader(mShader);
+  }
   mImpl->mRenderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK);
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 }
 
 void PrimitiveVisual::UpdateShaderUniforms()

diff --git a/dali-toolkit/internal/visuals/primitive/primitive-visual.h b/dali-toolkit/internal/visuals/primitive/primitive-visual.h
index 6608fefe292dd1d6065c9b58f21a3ba5aceaf0e8..e50d3132527f4e37af5f9bfa4b7bfae332049ba8 100644 (file)
--- a/dali-toolkit/internal/visuals/primitive/primitive-visual.h
+++ b/dali-toolkit/internal/visuals/primitive/primitive-visual.h
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_INTERNAL_PRIMITIVE_VISUAL_H
 
 /*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -155,6 +155,11 @@ protected:
    */
   void OnSetTransform() override;
 
+  /**
+   * @copydoc Visual::Base::UpdateShader
+   */
+  void UpdateShader() override;
+
 private:
   //Simple struct to store the position and normal of a single vertex.
   struct Vertex

diff --git a/dali-toolkit/internal/visuals/svg/svg-visual.cpp b/dali-toolkit/internal/visuals/svg/svg-visual.cpp
index 9f7610998dae1d67e379a9cca78aa39b042e0431..59136b83a48dbe1ea48a73c9a9d1d33bdc4af72a 100644 (file)
--- a/dali-toolkit/internal/visuals/svg/svg-visual.cpp
+++ b/dali-toolkit/internal/visuals/svg/svg-visual.cpp
@@ -116,6 +116,11 @@ void SvgVisual::OnInitialize()
   mImpl->mRenderer  = DecoratedVisualRenderer::New(geometry, shader);
   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
 
+  if(mImpl->mCustomShader)
+  {
+    mImpl->mRenderer.RegisterVisualTransformUniform();
+  }
+
   Vector2 dpi     = Stage::GetCurrent().GetDpi();
   float   meanDpi = (dpi.height + dpi.width) * 0.5f;
 
@@ -214,7 +219,7 @@ void SvgVisual::DoSetOnScene(Actor& actor)
   mImpl->mRenderer.SetTextures(textureSet);
 
   // Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 
   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 
@@ -491,7 +496,10 @@ void SvgVisual::OnSetTransform()
 {
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+
+    // TODO : We many need to less call it.
+    UpdateShader();
   }
 
   if(IsOnScene() && !mLoadFailed)
@@ -539,7 +547,8 @@ Shader SvgVisual::GenerateShader() const
       ImageVisualShaderFeature::FeatureBuilder()
         .EnableTextureAtlas(mImpl->mFlags & Visual::Base::Impl::IS_ATLASING_APPLIED)
         .EnableRoundedCorner(IsRoundedCornerRequired(), IsSquircleCornerRequired())
-        .EnableBorderline(IsBorderlineRequired()));
+        .EnableBorderline(IsBorderlineRequired())
+        .UseDefaultTransform(mImpl->mTransformMapUsingDefault));
   }
   else
   {
@@ -552,6 +561,11 @@ Shader SvgVisual::GenerateShader() const
     // Most of image visual shader user (like svg, animated vector image visual) use pre-multiplied alpha.
     // If the visual dont want to using pre-multiplied alpha, it should be set as 0.0f as renderer side.
     shader.RegisterProperty(PREMULTIPLIED_ALPHA, ALPHA_VALUE_PREMULTIPLIED);
+
+    if(mImpl->mRenderer)
+    {
+      mImpl->mRenderer.RegisterVisualTransformUniform();
+    }
   }
   return shader;
 }

diff --git a/dali-toolkit/internal/visuals/text/text-visual-shader-factory.cpp b/dali-toolkit/internal/visuals/text/text-visual-shader-factory.cpp
index d08c41154cf022b6438e4e502ea4d4f47f94baec..b0f263708692738c79bc518ccedac40166016ae1 100644 (file)
--- a/dali-toolkit/internal/visuals/text/text-visual-shader-factory.cpp
+++ b/dali-toolkit/internal/visuals/text/text-visual-shader-factory.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -167,7 +167,7 @@ Shader TextVisualShaderFactory::GetShader(VisualFactoryCache& factoryCache, cons
 {
   Shader                         shader;
   VisualFactoryCache::ShaderType shaderType = featureBuilder.GetShaderType();
-  shader                                    = factoryCache.GetShader(shaderType);
+  shader                                    = factoryCache.GetShader(shaderType, false);
 
   if(!shader)
   {
@@ -179,7 +179,7 @@ Shader TextVisualShaderFactory::GetShader(VisualFactoryCache& factoryCache, cons
     std::string vertexShader   = std::string(Dali::Shader::GetVertexShaderPrefix() + vertexShaderPrefixList + SHADER_TEXT_VISUAL_SHADER_VERT.data());
     std::string fragmentShader = std::string(Dali::Shader::GetFragmentShaderPrefix() + fragmentShaderPrefixList + SHADER_TEXT_VISUAL_SHADER_FRAG.data());
 
-    shader = factoryCache.GenerateAndSaveShader(shaderType, vertexShader, fragmentShader);
+    shader = factoryCache.GenerateAndSaveShader(shaderType, vertexShader, fragmentShader, false);
   }
   return shader;
 }

diff --git a/dali-toolkit/internal/visuals/text/text-visual.cpp b/dali-toolkit/internal/visuals/text/text-visual.cpp
index aab56eab8c0a0829f05f78953c48b65d9c064741..fcd77268bd35b9f934109e331151b0431473dd31 100644 (file)
--- a/dali-toolkit/internal/visuals/text/text-visual.cpp
+++ b/dali-toolkit/internal/visuals/text/text-visual.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -305,6 +305,7 @@ void TextVisual::OnInitialize()
   Shader   shader         = GetTextShader(mFactoryCache, featureBuilder);
 
   mImpl->mRenderer = VisualRenderer::New(geometry, shader);
+  mImpl->mRenderer.RegisterVisualTransformUniform();
   mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT);
   mTextRequireRenderPropertyIndex = mImpl->mRenderer.RegisterUniqueProperty("requireRender", mTextRequireRender);
   mHasMultipleTextColorsIndex     = mImpl->mRenderer.RegisterUniqueProperty("uHasMultipleTextColors", static_cast<float>(false));
@@ -711,7 +712,7 @@ void TextVisual::CreateTextureSet(TilingInfo& info, VisualRenderer& renderer, Sa
   renderer.SetTextures(textureSet);
 
   // Register transform properties
-  mImpl->mTransform.SetUniforms(renderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(renderer, Direction::LEFT_TO_RIGHT);
 
   // Enable the pre-multiplied alpha to improve the text quality
   renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
@@ -882,7 +883,7 @@ void TextVisual::LoadComplete(bool loadingSuccess, const TextInformation& textIn
 
       mImpl->mRenderer.SetTextures(textureSet);
       // Register transform properties
-      mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+      mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
       mImpl->mRenderer.SetProperty(mHasMultipleTextColorsIndex, static_cast<float>(mTextShaderFeatureCache.IsEnabledMultiColor()));
       mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
 
@@ -938,6 +939,7 @@ void TextVisual::LoadComplete(bool loadingSuccess, const TextInformation& textIn
       while(verifiedHeight > 0)
       {
         VisualRenderer tilingRenderer = VisualRenderer::New(geometry, shader);
+        tilingRenderer.RegisterVisualTransformUniform();
         tilingRenderer.SetProperty(Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT);
         // New offset position of buffer for tiling.
         info.offsetHeight += static_cast<uint32_t>(maxTextureSize);
@@ -1166,7 +1168,7 @@ void TextVisual::AddRenderer(Actor& actor, const Vector2& size, bool hasMultiple
 
     mImpl->mRenderer.SetTextures(textureSet);
     // Register transform properties
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
     mImpl->mRenderer.SetProperty(mHasMultipleTextColorsIndex, static_cast<float>(hasMultipleTextColors));
     mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
 
@@ -1235,6 +1237,7 @@ void TextVisual::AddRenderer(Actor& actor, const Vector2& size, bool hasMultiple
     while(verifiedHeight > 0)
     {
       VisualRenderer tilingRenderer = VisualRenderer::New(geometry, shader);
+      tilingRenderer.RegisterVisualTransformUniform();
       tilingRenderer.SetProperty(Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT);
       // New offset position of buffer for tiling.
       info.offsetHeight += maxTextureSize;

diff --git a/dali-toolkit/internal/visuals/visual-base-data-impl.cpp b/dali-toolkit/internal/visuals/visual-base-data-impl.cpp
index 698f4cff4b426c47b4af34bf6543f3bbc0a446c3..92681f3b60951e3382e8019c1ddc743317d77576 100644 (file)
--- a/dali-toolkit/internal/visuals/visual-base-data-impl.cpp
+++ b/dali-toolkit/internal/visuals/visual-base-data-impl.cpp
@@ -133,6 +133,7 @@ Internal::Visual::Base::Impl::Impl(FittingMode fittingMode, Toolkit::Visual::Typ
   mIgnoreFittingMode(false),
   mPixelAreaSetByFittingMode(false),
   mTransformMapSetForFittingMode(false),
+  mTransformMapUsingDefault(true),
   mTransformMapChanged(false)
 {
 }

diff --git a/dali-toolkit/internal/visuals/visual-base-data-impl.h b/dali-toolkit/internal/visuals/visual-base-data-impl.h
index 12a445affe57f6faf0bff2dd5c058674a82a6df9..2e0edd602eb35e53ddcb9c42f9fd156f3a7fad79 100644 (file)
--- a/dali-toolkit/internal/visuals/visual-base-data-impl.h
+++ b/dali-toolkit/internal/visuals/visual-base-data-impl.h
@@ -134,6 +134,19 @@ struct Base::Impl
     int     mCornerRadiusPolicy;
   };
 
+  /**
+   * @brief Set the uniform properties onto the renderer.
+   * And Register visual transform uniforms if neccessary.
+   */
+  void SetTransformUniforms(VisualRenderer renderer, Toolkit::Direction::Type direction)
+  {
+    if(!mTransformMapUsingDefault || direction != Toolkit::Direction::LEFT_TO_RIGHT)
+    {
+      renderer.RegisterVisualTransformUniform();
+      mTransform.SetUniforms(renderer, direction);
+    }
+  }
+
   DecorationData* EnsureDecorationData()
   {
     if(mDecorationData == nullptr)
@@ -282,7 +295,9 @@ struct Base::Impl
   bool                            mIgnoreFittingMode : 1;             ///< Whether we need to ignore fitting mode.
   bool                            mPixelAreaSetByFittingMode : 1;     ///< Whether the pixel area is set for fitting mode.
   bool                            mTransformMapSetForFittingMode : 1; ///< Whether the transformMap is set for fitting mode.
-  bool                            mTransformMapChanged : 1;           ///< Whether the transformMap is changed or not. We'll be false after SetTransform called.
+  bool                            mTransformMapUsingDefault : 1;      ///< Whether we are using the default transformMap not. We'll be false after SetTransform called, or animated.
+                                                                      ///< Note : If it change to false, never be true again.
+  bool mTransformMapChanged : 1;                                      ///< Whether the transformMap is changed or not. We'll be false after SetTransform called.
 };
 
 } // namespace Visual

diff --git a/dali-toolkit/internal/visuals/visual-base-impl.cpp b/dali-toolkit/internal/visuals/visual-base-impl.cpp
index b67016ffb5f2268123ec16df4831440050c0aa8e..84c8e0659302ccf82cc33af45392a22196f8b9ef 100644 (file)
--- a/dali-toolkit/internal/visuals/visual-base-impl.cpp
+++ b/dali-toolkit/internal/visuals/visual-base-impl.cpp
@@ -247,6 +247,11 @@ void Visual::Base::SetProperties(const Property::Map& propertyMap)
             // Unusual case. SetProperty called after OnInitialize().
             // Assume that DoAction call UPDATE_PROPERTY.
             mImpl->mTransformMapChanged |= !map.Empty();
+            if(mImpl->mTransformMapChanged)
+            {
+              mImpl->mTransformMapUsingDefault = false;
+              mImpl->mRenderer.RegisterVisualTransformUniform();
+            }
             mImpl->mTransform.UpdatePropertyMap(map);
 
             // Set Renderer uniforms, and change logics for subclasses.
@@ -257,6 +262,7 @@ void Visual::Base::SetProperties(const Property::Map& propertyMap)
           }
           else
           {
+            mImpl->mTransformMapUsingDefault &= map.Empty();
             mImpl->mTransform.SetPropertyMap(map);
           }
         }
@@ -531,6 +537,11 @@ void Visual::Base::SetTransformAndSize(const Property::Map& transform, Size cont
 {
   mImpl->mControlSize = controlSize;
   mImpl->mTransformMapChanged |= !transform.Empty();
+  if(mImpl->mTransformMapChanged)
+  {
+    mImpl->mTransformMapUsingDefault = false;
+    mImpl->mRenderer.RegisterVisualTransformUniform();
+  }
   mImpl->mTransform.UpdatePropertyMap(transform);
 
 #if defined(DEBUG_ENABLED)
@@ -1394,10 +1405,24 @@ Dali::Property Visual::Base::GetPropertyObject(Dali::Property::Key key)
     }
     case Toolkit::Visual::Transform::Property::OFFSET:
     {
+      // Need to change visual transform is not default anymore.
+      mImpl->mTransformMapUsingDefault = false;
+      mImpl->mRenderer.RegisterVisualTransformUniform();
+
+      // Change shader
+      UpdateShader();
+
       return Dali::Property(mImpl->mRenderer, VisualRenderer::Property::TRANSFORM_OFFSET);
     }
     case Toolkit::Visual::Transform::Property::SIZE:
     {
+      // Need to change visual transform is not default anymore.
+      mImpl->mTransformMapUsingDefault = false;
+      mImpl->mRenderer.RegisterVisualTransformUniform();
+
+      // Change shader
+      UpdateShader();
+
       return Dali::Property(mImpl->mRenderer, VisualRenderer::Property::TRANSFORM_SIZE);
     }
 

diff --git a/dali-toolkit/internal/visuals/visual-base-impl.h b/dali-toolkit/internal/visuals/visual-base-impl.h
index d8ff84b23a56f2a80cb600a2b91d9eb64a92e9b6..2280176fb3594198b081343a94e8db13f21a5ceb 100644 (file)
--- a/dali-toolkit/internal/visuals/visual-base-impl.h
+++ b/dali-toolkit/internal/visuals/visual-base-impl.h
@@ -425,8 +425,8 @@ protected:
 
   /**
    * @brief Generate a shader by the current properties from each sub classes's own shader-generate logic.
-   * @param[in] factoryCache The visual factory cache to store the generated shader.
    * @return If the function defined, Generated shader by the current properties. Else, empty shader.
+   * @todo This function should be removed after refactoring the shader generation logic.
    */
   virtual Dali::Shader GenerateShader() const
   {

diff --git a/dali-toolkit/internal/visuals/visual-factory-cache.cpp b/dali-toolkit/internal/visuals/visual-factory-cache.cpp
index 3675d0a4ab563f216ff4cbf4b8659519258c546b..8b76dee31c9218a94d61f1683abf8f0debf78c08 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) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 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.
@@ -24,6 +24,7 @@
 #include <dali/devel-api/scripting/enum-helper.h>
 #include <dali/devel-api/scripting/scripting.h>
 #include <dali/integration-api/debug.h>
+#include <dali/integration-api/shader-integ.h>
 #include <dali/public-api/math/math-utils.h>
 
 // INTERNAL INCLUDES
@@ -89,15 +90,28 @@ void VisualFactoryCache::SaveGeometry(GeometryType type, Geometry geometry)
   mGeometry[type] = geometry;
 }
 
-Shader VisualFactoryCache::GetShader(ShaderType type)
+Shader VisualFactoryCache::GetShader(ShaderType type, bool useDefaultUniforms)
 {
+  if(useDefaultUniforms)
+  {
+    return mDefaultShader[type];
+  }
   return mShader[type];
 }
 
-Shader VisualFactoryCache::GenerateAndSaveShader(ShaderType type, std::string_view vertexShader, std::string_view fragmentShader)
+Shader VisualFactoryCache::GenerateAndSaveShader(ShaderType type, std::string_view vertexShader, std::string_view fragmentShader, bool useDefaultUniforms)
 {
-  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;
+  Shader shader;
+  if(useDefaultUniforms)
+  {
+    shader               = Integration::ShaderNewWithUniformBlock(vertexShader, fragmentShader, Shader::Hint::NONE, Scripting::GetLinearEnumerationName<ShaderType>(type, VISUAL_SHADER_TYPE_TABLE, VISUAL_SHADER_TYPE_TABLE_COUNT), {GetDefaultUniformBlock()});
+    mDefaultShader[type] = shader;
+  }
+  else
+  {
+    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;
 }
 
@@ -164,6 +178,23 @@ VectorAnimationManager& VisualFactoryCache::GetVectorAnimationManager()
   return *mVectorAnimationManager;
 }
 
+Dali::UniformBlock& VisualFactoryCache::GetDefaultUniformBlock()
+{
+  if(!mDefaultUniformBlock)
+  {
+    // We should make default uniform block as overwritable.
+    mDefaultUniformBlock = Dali::UniformBlock::New("VisualVertBlock");
+
+    mDefaultUniformBlock.RegisterUniqueProperty("offset", Vector2::ZERO);
+    mDefaultUniformBlock.RegisterUniqueProperty("size", Vector2::ONE);
+    mDefaultUniformBlock.RegisterUniqueProperty("offsetSizeMode", Vector4::ZERO);
+    mDefaultUniformBlock.RegisterUniqueProperty("origin", -Vector2(0.5f, 0.5f));     ///< TOP_BEGIN for LTR
+    mDefaultUniformBlock.RegisterUniqueProperty("anchorPoint", Vector2(0.5f, 0.5f)); ///< TOP_BEGIN for LTR
+    mDefaultUniformBlock.RegisterUniqueProperty("extraSize", Vector2::ZERO);
+  }
+  return mDefaultUniformBlock;
+}
+
 void VisualFactoryCache::FinalizeVectorAnimationManager()
 {
   if(mVectorAnimationManager)
@@ -343,11 +374,11 @@ Shader VisualFactoryCache::GetNPatchShader(int index)
 
   if(DALI_LIKELY((xStretchCount == 0 && yStretchCount == 0) || (xStretchCount == 1 && yStretchCount == 1)))
   {
-    shader = GetShader(VisualFactoryCache::NINE_PATCH_SHADER);
+    shader = GetShader(VisualFactoryCache::NINE_PATCH_SHADER, false);
     if(DALI_UNLIKELY(!shader))
     {
       // Only cache vanilla 9 patch shaders
-      shader = GenerateAndSaveShader(VisualFactoryCache::NINE_PATCH_SHADER, SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, SHADER_NPATCH_VISUAL_SHADER_FRAG);
+      shader = GenerateAndSaveShader(VisualFactoryCache::NINE_PATCH_SHADER, SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, SHADER_NPATCH_VISUAL_SHADER_FRAG, false);
     }
   }
   else if(xStretchCount > 0 || yStretchCount > 0)
@@ -377,7 +408,7 @@ void VisualFactoryCache::ApplyTextureAndUniforms(Renderer& renderer, int index)
   }
 }
 
-void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size, const bool rendererIsImage)
+void VisualFactoryCache::UpdateBrokenImageRenderer(VisualRenderer& renderer, const Vector2& size, const bool rendererIsImage)
 {
   bool useDefaultBrokenImage = false;
   if(mBrokenImageInfoContainer.size() == 0)
@@ -443,6 +474,7 @@ void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vec
     // Set geometry and shader for npatch
     Geometry geometry = GetNPatchGeometry(brokenIndex);
     Shader   shader   = GetNPatchShader(brokenIndex);
+    renderer.RegisterVisualTransformUniform();
     renderer.SetGeometry(geometry);
     renderer.SetShader(shader);
     ApplyTextureAndUniforms(renderer, brokenIndex);
@@ -453,13 +485,14 @@ void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vec
     if(!rendererIsImage)
     {
       Geometry geometry = GetGeometry(QUAD_GEOMETRY);
-      Shader   shader   = GetShader(IMAGE_SHADER);
+      Shader   shader   = GetShader(IMAGE_SHADER, false);
       if(!shader)
       {
-        shader = GenerateAndSaveShader(IMAGE_SHADER, Dali::Shader::GetVertexShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_FRAG.data());
+        shader = GenerateAndSaveShader(IMAGE_SHADER, Dali::Shader::GetVertexShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_VERT.data(), Dali::Shader::GetFragmentShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_FRAG.data(), false);
         shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
         shader.RegisterProperty(PREMULTIPLIED_ALPHA, ALPHA_VALUE_PREMULTIPLIED);
       }
+      renderer.RegisterVisualTransformUniform();
       renderer.SetGeometry(geometry);
       renderer.SetShader(shader);
     }

diff --git a/dali-toolkit/internal/visuals/visual-factory-cache.h b/dali-toolkit/internal/visuals/visual-factory-cache.h
index a1b0caf62cde8cf4a218da077395424c5ebf507f..7763dc1ac50778e91b4fa545617ec0fc0857cfc2 100644 (file)
--- a/dali-toolkit/internal/visuals/visual-factory-cache.h
+++ b/dali-toolkit/internal/visuals/visual-factory-cache.h
@@ -22,6 +22,8 @@
 #include <dali/public-api/object/ref-object.h>
 #include <dali/public-api/rendering/geometry.h>
 #include <dali/public-api/rendering/shader.h>
+#include <dali/public-api/rendering/uniform-block.h>
+#include <dali/public-api/rendering/visual-renderer.h>
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/internal/texture-manager/texture-manager-impl.h>
@@ -221,16 +223,17 @@ public:
    * Request shader of the given type.
    * @return The shader of the required type if it exist in the cache. Otherwise, an empty handle is returned.
    */
-  Shader GetShader(ShaderType type);
+  Shader GetShader(ShaderType type, bool useDefaultUniforms = false);
 
   /**
    * Generate and cache the shader of the give type. The name of shader will be installed to shader.
    * @param[in] type The shder type.
    * @param[in] vertexShader The vertex shader code.
    * @param[in] fragmentShader The fragment shader code.
+   * @param[in] useDefaultUniforms Whether to use default uniforms or not.
    * @return The shader created by given vertex and fragment shader code.
    */
-  Shader GenerateAndSaveShader(ShaderType type, std::string_view vertexShader, std::string_view fragmentShader);
+  Shader GenerateAndSaveShader(ShaderType type, std::string_view vertexShader, std::string_view fragmentShader, bool useDefaultUniforms = false);
 
   /*
    * Greate the quad geometry.
@@ -269,7 +272,7 @@ public:
    *                            If true, we don't need to create new renderer when broken image is single image.
    *                            Most of user experience use normal images. So It can reduce runtime.
    */
-  void UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size, const bool rendererIsImage = true);
+  void UpdateBrokenImageRenderer(VisualRenderer& renderer, const Vector2& size, const bool rendererIsImage = true);
 
   /**
    * @brief Get whether we support YUV Planes load or not.
@@ -309,6 +312,12 @@ public:
    */
   VectorAnimationManager& GetVectorAnimationManager();
 
+  /**
+   * @brief Get the default uniform block. This is used to share common uniforms between different visuals.
+   * @return The uniform block with default value registered.
+   */
+  Dali::UniformBlock& GetDefaultUniformBlock();
+
   /**
    * @brief Finalize vector animation manager.
    * It will be called when application is terminated.
@@ -402,6 +411,7 @@ private:
 
   Geometry mGeometry[GEOMETRY_TYPE_MAX];
   Shader   mShader[SHADER_TYPE_MAX];
+  Shader   mDefaultShader[SHADER_TYPE_MAX];
 
   bool mLoadYuvPlanes; ///< A global flag to specify if the image should be loaded as yuv planes
 
@@ -410,6 +420,8 @@ private:
   NPatchLoader         mNPatchLoader;
   SvgLoader            mSvgLoader;
 
+  Dali::UniformBlock mDefaultUniformBlock;
+
   std::unique_ptr<VectorAnimationManager> mVectorAnimationManager;
   bool                                    mPreMultiplyOnLoad;
   std::vector<BrokenImageInfo>            mBrokenImageInfoContainer;

diff --git a/dali-toolkit/internal/visuals/wireframe/wireframe-visual.cpp b/dali-toolkit/internal/visuals/wireframe/wireframe-visual.cpp
index 14444b61dd9dcd668d9c95efb07c8728fde52680..052e8b58ec45f128d0e459af39b4c9eadcaf60e0 100644 (file)
--- a/dali-toolkit/internal/visuals/wireframe/wireframe-visual.cpp
+++ b/dali-toolkit/internal/visuals/wireframe/wireframe-visual.cpp
@@ -157,7 +157,7 @@ void WireframeVisual::OnInitialize()
   mImpl->mRenderer = VisualRenderer::New(geometry, shader);
 
   //Register transform properties
-  mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+  mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
 }
 
 Geometry WireframeVisual::CreateQuadWireframeGeometry()
@@ -197,7 +197,7 @@ void WireframeVisual::OnSetTransform()
   if(mImpl->mRenderer && mImpl->mTransformMapChanged)
   {
     //Register transform properties
-    mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
+    mImpl->SetTransformUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT);
   }
 }