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 f0f4943..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;
+// 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>& 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,16 +82,17 @@ void Node::Delete(Node* node)
 }
 
 Node::Node()
-: mOrientation(), // Initialized to identity by default
-  mVisible(true),
-  mCulled(false),
-  mColor(Color::WHITE),
-  mUpdateAreaHint(Vector4::ZERO),
+: 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
   mWorldMatrix(),
+  mVisible(true),
+  mCulled(false),
+  mColor(Color::WHITE),
   mWorldColor(Color::WHITE),
+  mUpdateAreaHint(Vector4::ZERO),
   mClippingSortModifier(0u),
   mId(++mNodeCounter),
   mParent(nullptr),
@@ -102,7 +109,9 @@ Node::Node()
   mIsLayer(false),
   mIsCamera(false),
   mPositionUsesAnchorPoint(true),
-  mTransparent(false)
+  mTransparent(false),
+  mUpdateAreaChanged(false),
+  mUseTextureUpdateArea(false)
 {
 #ifdef DEBUG_ENABLED
   gNodeCount++;
@@ -134,28 +143,14 @@ uint32_t Node::GetId() const
 
 void Node::CreateTransform(SceneGraph::TransformManager* transformManager)
 {
-  //Create a new transform
+  // Create a new transform
   mTransformManagerData.mManager = transformManager;
   TransformId createdTransformId = transformManager->CreateTransform();
 
-  //Initialize all the animatable properties
-  mPosition.Initialize(&mTransformManagerData);
-  mScale.Initialize(&mTransformManagerData);
-  mOrientation.Initialize(&mTransformManagerData);
-  mSize.Initialize(&mTransformManagerData);
-  mParentOrigin.Initialize(&mTransformManagerData);
-  mAnchorPoint.Initialize(&mTransformManagerData);
-
-  //Initialize all the input properties
-  mWorldPosition.Initialize(&mTransformManagerData);
-  mWorldScale.Initialize(&mTransformManagerData);
-  mWorldOrientation.Initialize(&mTransformManagerData);
-  mWorldMatrix.Initialize(&mTransformManagerData);
-
-  //Set whether the position should use the anchor point
+  // Set whether the position should use the anchor point
   transformManager->SetPositionUsesAnchorPoint(createdTransformId, mPositionUsesAnchorPoint);
 
-  //Set TransformId after initialize done.
+  // Set TransformId after initialize done.
   mTransformManagerData.mId = createdTransformId;
 }
 
@@ -171,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);
@@ -213,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)
       {
@@ -236,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;
     }
   }
@@ -270,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;
 }
 
@@ -292,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)
@@ -348,6 +332,11 @@ void Node::RecursiveDisconnectFromSceneGraph(BufferIndex updateBufferIndex)
   }
 }
 
+uint32_t Node::GetMemoryPoolCapacity()
+{
+  return GetNodeMemoryPool().GetCapacity();
+}
+
 } // namespace SceneGraph
 
 } // namespace Internal