[Tizen] Clear pipelie cache if geometry destroyed or buffer changed

We also cache pipeline cache the Render::Geometry by the raw pointer.
If someone use duplicated pointer, it might return invalid pipeline
with unmatched vertexInputState.

To avoid this issue, let we erase cache if Render::Geometry destroyed,
same as Render::Program

 - This is the commit message #2:

Reset cached pipeline if geometry buffer changed

Until now, we don't re-cache the geometry
if the vertex buffer added/removed, or data changed.

Since the vertex attribute might be changed if we try to use
same geometry, the rendering result
show some non-common results.

To fix this cache issue, let we ensure to reset the cached infomations
if the vertex buffer / indices buffer changed.

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

diff --git a/dali/internal/render/renderers/pipeline-cache.cpp b/dali/internal/render/renderers/pipeline-cache.cpp
index fea2efc4404003d3252ef0fe4ad0e760df7cf147..68e17d6bd7cc66c536bf5f890fce1bcf76e9bdec 100644 (file)
--- a/dali/internal/render/renderers/pipeline-cache.cpp
+++ b/dali/internal/render/renderers/pipeline-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.
@@ -514,6 +514,7 @@ PipelineCache::~PipelineCache()
     level0node.program->RemoveLifecycleObserver(*this);
     level0node.geometry->RemoveLifecycleObserver(*this);
   }
+  level0nodes.clear();
 }
 
 PipelineResult PipelineCache::GetPipeline(const PipelineCacheQueryInfo& queryInfo, bool createNewIfNotFound)
@@ -630,6 +631,14 @@ void PipelineCache::ProgramDestroyed(const Program* program)
   }
 }
 
+Geometry::LifecycleObserver::NotifyReturnType PipelineCache::GeometryBufferChanged(const Geometry* geometry)
+{
+  // Let just run the same logic with geometry destroyed cases.
+  GeometryDestroyed(geometry);
+
+  return Geometry::LifecycleObserver::NotifyReturnType::STOP_OBSERVING;
+}
+
 void PipelineCache::GeometryDestroyed(const Geometry* geometry)
 {
   // Remove latest used pipeline cache infomation.

diff --git a/dali/internal/render/renderers/pipeline-cache.h b/dali/internal/render/renderers/pipeline-cache.h
index c4ff35cb0f9d835f1e4404454bfa28a1f778e273..3bc6a31cd057befc6865d63c0543fb7ded9f328a 100644 (file)
--- a/dali/internal/render/renderers/pipeline-cache.h
+++ b/dali/internal/render/renderers/pipeline-cache.h
@@ -2,7 +2,7 @@
 #define DALI_INTERNAL_RENDER_PIPELINE_CACHE_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.
@@ -24,8 +24,8 @@
 #include <dali/public-api/common/list-wrapper.h>
 
 #include <dali/internal/common/blending-options.h>
-#include <dali/internal/render/shaders/program.h> ///< For Program::LifecycleObserver
 #include <dali/internal/render/renderers/render-geometry.h> ///< For Geometry::LifecycleObserver
+#include <dali/internal/render/shaders/program.h>           ///< For Program::LifecycleObserver
 
 namespace Dali::Internal
 {
@@ -188,6 +188,11 @@ public: // From Program::LifecycleObserver
   void ProgramDestroyed(const Program* program);
 
 public: // From Geometry::LifecycleObserver
+  /**
+   * @copydoc Dali::Internal::Geometry::LifecycleObserver::GeometryBufferChanged()
+   */
+  Geometry::LifecycleObserver::NotifyReturnType GeometryBufferChanged(const Geometry* geometry);
+
   /**
    * @copydoc Dali::Internal::Geometry::LifecycleObserver::GeometryDestroyed()
    */

diff --git a/dali/internal/render/renderers/render-geometry.cpp b/dali/internal/render/renderers/render-geometry.cpp
index 09dcf8933324f910c53f748eff430d8a8ac03002..6c3f0ec2011c228b06cf468dff4b6d2550ca20e4 100644 (file)
--- a/dali/internal/render/renderers/render-geometry.cpp
+++ b/dali/internal/render/renderers/render-geometry.cpp
@@ -165,6 +165,25 @@ void Geometry::Upload(Graphics::Controller& graphicsController)
     }
 
     mHasBeenUploaded = true;
+
+    // Notify to observers that geometry informations are changed
+    if(mUpdated)
+    {
+      mObserverNotifying = true;
+      for(auto iter = mLifecycleObservers.begin(); iter != mLifecycleObservers.end();)
+      {
+        auto returnValue = (*iter).first->GeometryBufferChanged(this);
+        if(returnValue == LifecycleObserver::KEEP_OBSERVING)
+        {
+          ++iter;
+        }
+        else
+        {
+          iter = mLifecycleObservers.erase(iter);
+        }
+      }
+      mObserverNotifying = false;
+    }
   }
 }
 

diff --git a/dali/internal/render/renderers/render-geometry.h b/dali/internal/render/renderers/render-geometry.h
index be7744b0543d1fdb82071f70ac0e2f583acea2f7..804c15f50025e656de1f06f9d99d10c713c1b13f 100644 (file)
--- a/dali/internal/render/renderers/render-geometry.h
+++ b/dali/internal/render/renderers/render-geometry.h
@@ -60,10 +60,24 @@ public:
   class LifecycleObserver
   {
   public:
+    enum NotifyReturnType
+    {
+      STOP_OBSERVING,
+      KEEP_OBSERVING,
+    };
+
+  public:
+    /**
+     * Called shortly if the geometry indices or vertex buffers are changed.
+     * @return NotifyReturnType::STOP_OBSERVING if we will not observe this object after this called
+     *         NotifyReturnType::KEEP_OBSERVING if we will observe this object after this called.
+     */
+    virtual NotifyReturnType GeometryBufferChanged(const Geometry* geometry) = 0;
+
     /**
-     * Called shortly before the program is destroyed.
+     * Called shortly before the geometry is destroyed.
      */
-    virtual void GeometryDestroyed(const Geometry* program) = 0;
+    virtual void GeometryDestroyed(const Geometry* geometry) = 0;
 
   protected:
     /**

diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp
index 06d1e1a1bfa713a817894c0aa9ced36419fa19b8..799893a3a92b1f940625194c45013911832ec637 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.cpp
+++ b/dali/internal/render/renderers/render-renderer.cpp
@@ -158,6 +158,12 @@ void Renderer::Initialize(Graphics::Controller& graphicsController, ProgramCache
   mProgramCache         = &programCache;
   mUniformBufferManager = &uniformBufferManager;
   mPipelineCache        = &pipelineCache;
+
+  // Add Observer now
+  if(mGeometry)
+  {
+    mGeometry->AddLifecycleObserver(*this);
+  }
 }
 
 Renderer::~Renderer()
@@ -175,6 +181,11 @@ Renderer::~Renderer()
     mCurrentProgram->RemoveLifecycleObserver(*this);
     mCurrentProgram = nullptr;
   }
+  if(mGeometry)
+  {
+    mGeometry->RemoveLifecycleObserver(*this);
+    mGeometry = nullptr;
+  }
 }
 
 void Renderer::operator delete(void* ptr)
@@ -189,13 +200,26 @@ Renderer* Renderer::Get(RendererKey::KeyType rendererKey)
 
 void Renderer::SetGeometry(Render::Geometry* geometry)
 {
-  mGeometry = geometry;
-
-  // Reset old pipeline
-  if(DALI_LIKELY(mPipelineCached))
+  if(mGeometry != geometry)
   {
-    mPipelineCache->ResetPipeline(mPipeline);
-    mPipelineCached = false;
+    if(mGeometry)
+    {
+      mGeometry->RemoveLifecycleObserver(*this);
+    }
+
+    mGeometry = geometry;
+
+    if(mGeometry)
+    {
+      mGeometry->AddLifecycleObserver(*this);
+    }
+
+    // Reset old pipeline
+    if(DALI_LIKELY(mPipelineCached))
+    {
+      mPipelineCache->ResetPipeline(mPipeline);
+      mPipelineCached = false;
+    }
   }
 }
 
@@ -1058,6 +1082,27 @@ void Renderer::ProgramDestroyed(const Program* program)
 #endif
 }
 
+Geometry::LifecycleObserver::NotifyReturnType Renderer::GeometryBufferChanged(const Geometry* geometry)
+{
+  DALI_ASSERT_ALWAYS(mGeometry == geometry && "Something wrong happend when Render::Renderer observed by geometry!");
+
+  // Reset old pipeline
+  if(DALI_LIKELY(mPipelineCached))
+  {
+    mPipelineCache->ResetPipeline(mPipeline);
+    mPipelineCached = false;
+  }
+
+  return Geometry::LifecycleObserver::NotifyReturnType::KEEP_OBSERVING;
+}
+
+void Renderer::GeometryDestroyed(const Geometry* geometry)
+{
+  // Let just run the same logic with geometry buffer changed cases.
+  [[maybe_unused]] auto ret = GeometryBufferChanged(geometry);
+  mGeometry                 = nullptr;
+}
+
 Vector4 Renderer::GetTextureUpdateArea() const noexcept
 {
   Vector4 result = Vector4::ZERO;

diff --git a/dali/internal/render/renderers/render-renderer.h b/dali/internal/render/renderers/render-renderer.h
index 3f638a3b6ed74985b36422f2afc6a1f73adf2df9..28d5c52a19ece453f803f22724cd23b471837e7e 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.h
+++ b/dali/internal/render/renderers/render-renderer.h
@@ -88,7 +88,7 @@ namespace Render
  * These objects are used during RenderManager::Render(), so properties modified during
  * the Update must either be double-buffered, or set via a message added to the RenderQueue.
  */
-class Renderer : public Program::LifecycleObserver
+class Renderer : public Program::LifecycleObserver, public Geometry::LifecycleObserver
 {
 public:
   /**
@@ -548,6 +548,17 @@ public: // From Program::LifecycleObserver
    */
   void ProgramDestroyed(const Program* program);
 
+public: // From Geometry::LifecycleObserver
+  /**
+   * @copydoc Dali::Internal::Geometry::LifecycleObserver::GeometryBufferChanged()
+   */
+  Geometry::LifecycleObserver::NotifyReturnType GeometryBufferChanged(const Geometry* geometry);
+
+  /**
+   * @copydoc Dali::Internal::Geometry::LifecycleObserver::GeometryDestroyed()
+   */
+  void GeometryDestroyed(const Geometry* geometry);
+
 private:
   struct UniformIndexMap;