Minor optimize during build uniform index maps

If node don't have any uniform properies,
we don't need to create about that node's index map.
Because that mean, this node will use only for renderItem's uniform.

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

diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp
index dd6c207..b481a8a 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.cpp
+++ b/dali/internal/render/renderers/render-renderer.cpp
@@ -566,18 +566,24 @@ int Renderer::BuildUniformIndexMap(BufferIndex bufferIndex, const SceneGraph::No
   // Usual case is to only have 1 node, however we do allow multiple nodes to reuse the same
   // renderer, so we have to cache uniform map per render item (node / renderer pair).
 
-  const void* nodePtr = static_cast<const void*>(&node);
-  auto        iter    = std::find_if(mNodeIndexMap.begin(), mNodeIndexMap.end(), [nodePtr](RenderItemLookup& element) { return element.node == nodePtr; });
+  // Specially, if node don't have uniformMap, we mark nodePtr as nullptr.
+  // So, all nodes without uniformMap will share same UniformIndexMap, contains only render data providers.
+  const auto nodePtr = uniformMapNode.Count() ? &node : nullptr;
+
+  const auto nodeChangeCounter          = nodePtr ? uniformMapNode.GetChangeCounter() : 0;
+  const auto renderItemMapChangeCounter = uniformMap.GetChangeCounter();
+
+  auto iter = std::find_if(mNodeIndexMap.begin(), mNodeIndexMap.end(), [nodePtr](RenderItemLookup& element) { return element.node == nodePtr; });
 
   int renderItemMapIndex;
   if(iter == mNodeIndexMap.end())
   {
     renderItemMapIndex = mUniformIndexMaps.size();
     RenderItemLookup renderItemLookup;
-    renderItemLookup.node                       = &node;
+    renderItemLookup.node                       = nodePtr;
     renderItemLookup.index                      = renderItemMapIndex;
-    renderItemLookup.nodeChangeCounter          = uniformMapNode.GetChangeCounter();
-    renderItemLookup.renderItemMapChangeCounter = uniformMap.GetChangeCounter();
+    renderItemLookup.nodeChangeCounter          = nodeChangeCounter;
+    renderItemLookup.renderItemMapChangeCounter = renderItemMapChangeCounter;
     mNodeIndexMap.emplace_back(renderItemLookup);
 
     updateMaps = true;
@@ -587,12 +593,12 @@ int Renderer::BuildUniformIndexMap(BufferIndex bufferIndex, const SceneGraph::No
   {
     renderItemMapIndex = iter->index;
 
-    updateMaps = (uniformMapNode.GetChangeCounter() != iter->nodeChangeCounter) ||
-                 (uniformMap.GetChangeCounter() != iter->renderItemMapChangeCounter) ||
+    updateMaps = (nodeChangeCounter != iter->nodeChangeCounter) ||
+                 (renderItemMapChangeCounter != iter->renderItemMapChangeCounter) ||
                  (mUniformIndexMaps[renderItemMapIndex].size() == 0);
 
-    iter->nodeChangeCounter          = uniformMapNode.GetChangeCounter();
-    iter->renderItemMapChangeCounter = uniformMap.GetChangeCounter();
+    iter->nodeChangeCounter          = nodeChangeCounter;
+    iter->renderItemMapChangeCounter = renderItemMapChangeCounter;
   }
 
   if(updateMaps || mShaderChanged)

diff --git a/dali/internal/render/renderers/render-renderer.h b/dali/internal/render/renderers/render-renderer.h
index 4156671..1523aa4 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.h
+++ b/dali/internal/render/renderers/render-renderer.h
@@ -566,7 +566,7 @@ private:
   /** Struct to map node to index into mNodeMapCounters and mUniformIndexMaps */
   struct RenderItemLookup
   {
-    const SceneGraph::NodeDataProvider* node{nullptr}; ///<Node key
+    const SceneGraph::NodeDataProvider* node{nullptr}; ///<Node key. It can be nullptr if this NodeIndex don't need node uniform
 
     std::size_t index{0};                       ///<Index into mUniformIndexMap
     std::size_t nodeChangeCounter{0};           ///<The last known change counter for this node's uniform map