Ensure initialize fransform data

[platform/core/uifw/dali-core.git] / dali / internal / update / nodes / node.cpp

diff --git a/dali/internal/update/nodes/node.cpp b/dali/internal/update/nodes/node.cpp
index 4291f47..55447df 100644 (file)
--- a/dali/internal/update/nodes/node.cpp
+++ b/dali/internal/update/nodes/node.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 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.
@@ -25,11 +25,17 @@
 #include <dali/public-api/common/constants.h>
 #include <dali/public-api/common/dali-common.h>
 
+#include <dali/internal/update/common/resetter-manager.h> ///< For AddInitializeResetter
+
 namespace
 {
 // Memory pool used to allocate new nodes. Memory used by this pool will be released when process dies
 //  or DALI library is unloaded
-Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Node> gNodeMemoryPool;
+Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Node>& GetNodeMemoryPool()
+{
+  static Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Node> gNodeMemoryPool;
+  return gNodeMemoryPool;
+}
 #ifdef DEBUG_ENABLED
 // keep track of nodes alive, to ensure we have 0 when the process exits or DALi library is unloaded
 int32_t gNodeCount = 0;
@@ -54,7 +60,7 @@ uint32_t Node::mNodeCounter = 0; ///< A counter to provide unique node ids, up-t
 
 Node* Node::New()
 {
-  return new(gNodeMemoryPool.AllocateRawThreadSafe()) Node;
+  return new(GetNodeMemoryPool().AllocateRawThreadSafe()) Node;
 }
 
 void Node::Delete(Node* node)
@@ -66,7 +72,7 @@ void Node::Delete(Node* node)
     node->~Node();
 
     // Mark the memory it used as free in the memory pool
-    gNodeMemoryPool.FreeThreadSafe(node);
+    GetNodeMemoryPool().FreeThreadSafe(node);
   }
   else
   {
@@ -76,7 +82,8 @@ void Node::Delete(Node* node)
 }
 
 Node::Node()
-: mOrientation(),                                                               // Initialized to identity by default
+: mTransformManagerData(),                                                      // Initialized to use invalid id by default
+  mOrientation(),                                                               // Initialized to identity by default
   mWorldPosition(TRANSFORM_PROPERTY_WORLD_POSITION, Vector3(0.0f, 0.0f, 0.0f)), // Zero initialized by default
   mWorldScale(TRANSFORM_PROPERTY_WORLD_SCALE, Vector3(1.0f, 1.0f, 1.0f)),
   mWorldOrientation(), // Initialized to identity by default
@@ -102,7 +109,9 @@ Node::Node()
   mIsLayer(false),
   mIsCamera(false),
   mPositionUsesAnchorPoint(true),
-  mTransparent(false)
+  mTransparent(false),
+  mUpdateAreaChanged(false),
+  mUseTextureUpdateArea(false)
 {
 #ifdef DEBUG_ENABLED
   gNodeCount++;
@@ -157,6 +166,11 @@ bool Node::IsAnimationPossible() const
   return mIsConnectedToSceneGraph;
 }
 
+void Node::AddInitializeResetter(ResetterManager& manager) const
+{
+  manager.AddNodeResetter(*this);
+}
+
 void Node::ConnectChild(Node* childNode)
 {
   DALI_ASSERT_ALWAYS(this != childNode);
@@ -199,18 +213,18 @@ void Node::DisconnectChild(BufferIndex updateBufferIndex, Node& childNode)
   found->RecursiveDisconnectFromSceneGraph(updateBufferIndex);
 }
 
-void Node::AddRenderer(Renderer* renderer)
+void Node::AddRenderer(const RendererKey& renderer)
 {
   // If it is the first renderer added, make sure the world transform will be calculated
   // in the next update as world transform is not computed if node has no renderers.
-  if(mRenderer.Empty())
+  if(mRenderers.Empty())
   {
     mDirtyFlags |= NodePropertyFlags::TRANSFORM;
   }
   else
   {
     // Check that it has not been already added.
-    for(auto&& existingRenderer : mRenderer)
+    for(auto&& existingRenderer : mRenderers)
     {
       if(existingRenderer == renderer)
       {
@@ -222,18 +236,20 @@ void Node::AddRenderer(Renderer* renderer)
 
   SetUpdated(true);
 
-  mRenderer.PushBack(renderer);
+  mRenderers.PushBack(renderer);
 }
 
-void Node::RemoveRenderer(const Renderer* renderer)
+void Node::RemoveRenderer(const RendererKey& renderer)
 {
-  RendererContainer::SizeType rendererCount(mRenderer.Size());
+  RendererContainer::SizeType rendererCount(mRenderers.Size());
   for(RendererContainer::SizeType i = 0; i < rendererCount; ++i)
   {
-    if(mRenderer[i] == renderer)
+    if(mRenderers[i] == renderer)
     {
+      renderer->DetachFromNodeDataProvider(*this);
+
       SetUpdated(true);
-      mRenderer.Erase(mRenderer.Begin() + i);
+      mRenderers.Erase(mRenderers.Begin() + i);
       return;
     }
   }
@@ -256,12 +272,6 @@ NodePropertyFlags Node::GetDirtyFlags() const
     flags |= NodePropertyFlags::COLOR;
   }
 
-  // Check whether the update area property has changed
-  if(!mUpdateAreaHint.IsClean())
-  {
-    flags |= NodePropertyFlags::TRANSFORM;
-  }
-
   return flags;
 }
 
@@ -278,20 +288,8 @@ NodePropertyFlags Node::GetInheritedDirtyFlags(NodePropertyFlags parentFlags) co
 void Node::ResetDirtyFlags(BufferIndex updateBufferIndex)
 {
   mDirtyFlags = NodePropertyFlags::NOTHING;
-}
 
-void Node::UpdateUniformHash(BufferIndex bufferIndex)
-{
-  uint64_t hash = 0xc70f6907UL;
-  for(uint32_t i = 0u, count = mUniformMaps.Count(); i < count; ++i)
-  {
-    hash = mUniformMaps[i].propertyPtr->Hash(bufferIndex, hash);
-  }
-  if(mUniformsHash != hash)
-  {
-    mUniformsHash = hash;
-    SetUpdated(true);
-  }
+  mUpdateAreaChanged = false;
 }
 
 void Node::SetParent(Node& parentNode)
@@ -334,6 +332,11 @@ void Node::RecursiveDisconnectFromSceneGraph(BufferIndex updateBufferIndex)
   }
 }
 
+uint32_t Node::GetMemoryPoolCapacity()
+{
+  return GetNodeMemoryPool().GetCapacity();
+}
+
 } // namespace SceneGraph
 
 } // namespace Internal