(VisualRenderer) Forcibly ignore shared UBO if we call RegisterVisualTransformUniform()

Since the change of Pipeline give overhead for real world applications,
let we just forcibly ignore shared UBO if we don't use default visual UBO cases.

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

diff --git a/dali/internal/event/rendering/visual-renderer-impl.cpp b/dali/internal/event/rendering/visual-renderer-impl.cpp
index c70d61f0be10278011d225c823ec62d213707c4c..6261f778591433b651e47ed3d0958ce067d9e7e7 100644 (file)
--- a/dali/internal/event/rendering/visual-renderer-impl.cpp
+++ b/dali/internal/event/rendering/visual-renderer-impl.cpp
@@ -25,6 +25,7 @@
 #include <dali/internal/event/common/property-input-impl.h>
 #include <dali/internal/update/common/animatable-property-messages.h>
 #include <dali/internal/update/manager/update-manager.h>
+#include <dali/internal/update/rendering/scene-graph-renderer-messages.h>
 #include <dali/internal/update/rendering/scene-graph-renderer.h>
 #include <dali/public-api/object/type-registry.h>
 
@@ -522,6 +523,10 @@ void VisualRenderer::RegisterVisualTransformUniform()
 {
   if(!mUniformMapped)
   {
+    // Mark as we will not use shared uniform block.
+    // TODO : Currently, we ignore whole shared uniform blocks. We should specify the name of UBO in future.
+    EnableSharedUniformBlockMessage(GetEventThreadServices(), GetRendererSceneObject(), false);
+
     mUniformMapped = true;
     AddUniformMapping(Dali::VisualRenderer::Property::TRANSFORM_OFFSET, ConstString("offset"));
     AddUniformMapping(Dali::VisualRenderer::Property::TRANSFORM_SIZE, ConstString("size"));

diff --git a/dali/internal/render/common/render-manager.cpp b/dali/internal/render/common/render-manager.cpp
index a8e86eebbbb0a1c33cc7a2fdb03b4b8732e745f4..8ae43a334f62d70cdabdbf0c606c41002c87f5e0 100644 (file)
--- a/dali/internal/render/common/render-manager.cpp
+++ b/dali/internal/render/common/render-manager.cpp
@@ -1104,6 +1104,11 @@ void RenderManager::RenderScene(Integration::RenderStatus& status, Integration::
 
               totalSizeCPU += memoryRequirements.totalCpuSizeRequired;
               totalSizeGPU += memoryRequirements.totalGpuSizeRequired;
+
+              if(!item.mRenderer->UseSharedUniformBlock())
+              {
+                totalSizeGPU += memoryRequirements.sharedGpuSizeRequired;
+              }
             }
           }
         }

diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp
index 2cbd5da70a69e49e5e8a592f06329057bbf0ba07..a729ef9a1442b7215c522f43eb734d6b09f4d09f 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.cpp
+++ b/dali/internal/render/renderers/render-renderer.cpp
@@ -156,7 +156,8 @@ Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider,
   mDepthTestMode(depthTestMode),
   mPremultipliedAlphaEnabled(preMultipliedAlphaEnabled),
   mShaderChanged(false),
-  mPipelineCached(false)
+  mPipelineCached(false),
+  mUseSharedUniformBlock(true)
 {
   if(blendingBitmask != 0u)
   {
@@ -830,7 +831,8 @@ void Renderer::WriteUniformBuffer(
       mUniformBufferBindings[i].dataSize = reflection.GetUniformBlockSize(i);
 
       bool useSharedBlock = !standaloneUniforms &&
-                            programRequirements.sharedBlock[i];
+                            programRequirements.sharedBlock[i] &&
+                            UseSharedUniformBlock();
 
       if(useSharedBlock)
       {
@@ -1013,7 +1015,6 @@ void Renderer::FillUniformBuffer(Program&                             program,
         auto* ubo = uboViews[uniform.uniformBlockIndex];
         if(ubo == nullptr) // Uniform belongs to shared UniformBlock, can't overwrite
         {
-          uniform.state = UniformIndexMap::State::NOT_USED;
           continue;
         }
         WriteDynUniform(iter.propertyValue, uniform, *ubo, updateBufferIndex);

diff --git a/dali/internal/render/renderers/render-renderer.h b/dali/internal/render/renderers/render-renderer.h
index 2ce51494da7ce1dec390b654793ac37e2bb82198..182c6fd8a770231138b43ca5231be36f74f69acd 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.h
+++ b/dali/internal/render/renderers/render-renderer.h
@@ -550,6 +550,28 @@ public:
    */
   Vector4 GetTextureUpdateArea() const noexcept;
 
+  /**
+   * @brief Mark whether we should consider shared uniform block, or ignore it.
+   * @todo Currently, we ignore whole shared uniform blocks. We should specify the name of UBO in future.
+   *
+   * @param[in] enabled True if we will use shared uniform block. False otherwise.
+   */
+  void EnableSharedUniformBlock(bool enabled)
+  {
+    mUseSharedUniformBlock = enabled;
+  }
+
+  /**
+   * @brief Check whether we should consider shared uniform block, or ignore it.
+   * @todo Currently, we ignore whole shared uniform blocks. We should specify the name of UBO in future.
+   *
+   * @return True if we will use shared uniform block. False otherwise.
+   */
+  [[nodiscard]] bool UseSharedUniformBlock() const
+  {
+    return mUseSharedUniformBlock;
+  }
+
 public: // From Program::LifecycleObserver
   /**
    * @copydoc Dali::Internal::Program::LifecycleObserver::ProgramDestroyed()
@@ -731,6 +753,7 @@ private:
   bool                  mPremultipliedAlphaEnabled : 1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
   bool                  mShaderChanged : 1;             ///< Flag indicating the shader changed and uniform maps have to be updated
   bool                  mPipelineCached : 1;            ///< Flag indicating whether renderer cache valid pipeline or not.
+  bool                  mUseSharedUniformBlock : 1;     ///< Flag whether we should use shared uniform block or not. Usually it must be true.
 
   std::vector<Dali::DevelRenderer::DrawCommand> mDrawCommands; // Devel stuff
   RenderCallback*                               mRenderCallback{nullptr};

diff --git a/dali/internal/update/rendering/scene-graph-renderer-messages.h b/dali/internal/update/rendering/scene-graph-renderer-messages.h
index 4f648dc6cee6465370c01e72ff480b30afb0a95f..7b8d308d0dcd1fe9ed2197ae2d6312a00117d295 100644 (file)
--- a/dali/internal/update/rendering/scene-graph-renderer-messages.h
+++ b/dali/internal/update/rendering/scene-graph-renderer-messages.h
@@ -330,6 +330,13 @@ inline void SetUpdateAreaExtentsMessage(EventThreadServices& eventThreadServices
   new(slot) LocalType(&renderer, &SceneGraph::Renderer::SetUpdateAreaExtents, updateAreaExtents);
 }
 
+inline void EnableSharedUniformBlockMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, bool enabled)
+{
+  using LocalType = MessageValue1<Renderer, bool>;
+  uint32_t* slot  = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
+  new(slot) LocalType(&renderer, &Renderer::EnableSharedUniformBlock, enabled);
+}
+
 } // namespace Dali::Internal::SceneGraph
 
 #endif //DALI_INTERNAL_SCENE_GRAPH_RENDERER_MESSAGES_H

diff --git a/dali/internal/update/rendering/scene-graph-renderer.cpp b/dali/internal/update/rendering/scene-graph-renderer.cpp
index 474f20555d0269aaf893e16741840a0e51d6d36c..fd4d20b7b9acc3efca8f1c331d41ccdd664dde19 100644 (file)
--- a/dali/internal/update/rendering/scene-graph-renderer.cpp
+++ b/dali/internal/update/rendering/scene-graph-renderer.cpp
@@ -81,7 +81,8 @@ enum Flags
   RESEND_WRITE_TO_COLOR_BUFFER       = 1 << 18,
   RESEND_SHADER                      = 1 << 19,
   RESEND_DRAW_COMMANDS               = 1 << 20,
-  RESEND_SET_RENDER_CALLBACK         = 1 << 21
+  RESEND_SET_RENDER_CALLBACK         = 1 << 21,
+  RESEND_SHARED_UNIFORM_BLOCK_USED   = 1 << 22,
 };
 
 inline Vector4 AdjustExtents(const Vector4& updateArea, const Dali::Extents& updateAreaExtents)
@@ -135,6 +136,7 @@ Renderer::Renderer()
   mVisualPropertiesDirtyFlags(CLEAN_FLAG),
   mRegenerateUniformMap(false),
   mPremultipledAlphaEnabled(false),
+  mUseSharedUniformBlock(true),
   mMixColor(Color::WHITE),
   mDepthIndex(0)
 {
@@ -353,6 +355,13 @@ bool Renderer::PrepareRender(BufferIndex updateBufferIndex)
       uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
       new(slot) DerivedType(rendererPtr, &Render::Renderer::SetRenderCallback, mRenderCallback);
     }
+
+    if(mResendFlag & RESEND_SHARED_UNIFORM_BLOCK_USED)
+    {
+      using DerivedType = MessageValue1<Render::Renderer, bool>;
+      uint32_t* slot    = mSceneController->GetRenderQueue().ReserveMessageSlot(updateBufferIndex, sizeof(DerivedType));
+      new(slot) DerivedType(rendererPtr, &Render::Renderer::EnableSharedUniformBlock, mUseSharedUniformBlock);
+    }
     mResendFlag = 0;
   }
 
@@ -923,6 +932,16 @@ const CollectedUniformMap& Renderer::GetCollectedUniformMap() const
   return mCollectedUniformMap;
 }
 
+void Renderer::EnableSharedUniformBlock(bool enabled)
+{
+  if(mUseSharedUniformBlock != enabled)
+  {
+    mUseSharedUniformBlock = enabled;
+    mResendFlag |= RESEND_SHARED_UNIFORM_BLOCK_USED;
+    SetUpdated(true);
+  }
+}
+
 bool Renderer::IsUpdated() const
 {
   // We should check Whether

diff --git a/dali/internal/update/rendering/scene-graph-renderer.h b/dali/internal/update/rendering/scene-graph-renderer.h
index 9f6aae8ea29306550d10799ffc708cbfcb908db0..0141fba155e9cbaf299cacba19c59f1138564ff7 100644 (file)
--- a/dali/internal/update/rendering/scene-graph-renderer.h
+++ b/dali/internal/update/rendering/scene-graph-renderer.h
@@ -560,6 +560,12 @@ public: // From UniformMapDataProvider
    */
   const CollectedUniformMap& GetCollectedUniformMap() const override;
 
+public: // For VisualRenderer
+  /**
+   * Mark whether we should consider shared uniform block, or ignore it.
+   */
+  void EnableSharedUniformBlock(bool enabled);
+
 public: // For VisualProperties
   /**
    * To be used only for 1st stage initialization in event thread.
@@ -640,6 +646,7 @@ private:
 
   bool mRegenerateUniformMap : 1;     ///< true if the map should be regenerated
   bool mPremultipledAlphaEnabled : 1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
+  bool mUseSharedUniformBlock : 1;
 
   std::vector<Dali::DevelRenderer::DrawCommand> mDrawCommands;
   Dali::RenderCallback*                         mRenderCallback{nullptr};