dali/internal/update/nodes/node.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/update/nodes/node.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/internal/common/internal-constants.h>
  23 #include <dali/internal/common/memory-pool-object-allocator.h>
  24 #include <dali/internal/update/common/discard-queue.h>
  25 #include <dali/public-api/common/dali-common.h>
  26 #include <dali/public-api/common/constants.h>
  27
  28 namespace
  29 {
  30 //Memory pool used to allocate new nodes. Memory used by this pool will be released when process dies
  31 // or DALI library is unloaded
  32 Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Node> gNodeMemoryPool;
  33 #ifdef DEBUG_ENABLED
  34 // keep track of nodes alive, to ensure we have 0 when the process exits or DALi library is unloaded
  35 int32_t gNodeCount = 0;
  36
  37 // Called when the process is about to exit, Node count should be zero at this point.
  38 void __attribute__ ((destructor)) ShutDown(void)
  39 {
  40 DALI_ASSERT_DEBUG( (gNodeCount == 0) && "Node memory leak");
  41 }
  42 #endif
  43 } // Unnamed namespace
  44
  45 namespace Dali
  46 {
  47
  48 namespace Internal
  49 {
  50
  51 namespace SceneGraph
  52 {
  53
  54 const ColorMode Node::DEFAULT_COLOR_MODE( USE_OWN_MULTIPLY_PARENT_ALPHA );
  55
  56 uint32_t Node::mNodeCounter = 0;        ///< A counter to provide unique node ids, up-to 4 billion
  57
  58 Node* Node::New()
  59 {
  60   return new ( gNodeMemoryPool.AllocateRawThreadSafe() ) Node;
  61 }
  62
  63 void Node::Delete( Node* node )
  64 {
  65   // check we have a node not a layer
  66   if( !node->mIsLayer )
  67   {
  68     // Manually call the destructor
  69     node->~Node();
  70
  71     // Mark the memory it used as free in the memory pool
  72     gNodeMemoryPool.FreeThreadSafe( node );
  73   }
  74   else
  75   {
  76     // not in the pool, just delete it.
  77     delete node;
  78   }
  79 }
  80
  81 Node::Node()
  82 : mOrientation(),                                                                 // Initialized to identity by default
  83   mVisible( true ),
  84   mCulled( false ),
  85   mColor( Color::WHITE ),
  86   mUpdateSizeHint( Vector3::ZERO ),
  87   mWorldPosition( TRANSFORM_PROPERTY_WORLD_POSITION, Vector3( 0.0f,0.0f,0.0f ) ), // Zero initialized by default
  88   mWorldScale( TRANSFORM_PROPERTY_WORLD_SCALE, Vector3( 1.0f,1.0f,1.0f ) ),
  89   mWorldOrientation(),                                                            // Initialized to identity by default
  90   mWorldMatrix(),
  91   mWorldColor( Color::WHITE ),
  92   mClippingSortModifier( 0u ),
  93   mId( ++mNodeCounter ),
  94   mParent( nullptr ),
  95   mExclusiveRenderTask( nullptr ),
  96   mChildren(),
  97   mClippingDepth( 0u ),
  98   mScissorDepth( 0u ),
  99   mDepthIndex( 0u ),
 100   mDirtyFlags( NodePropertyFlags::ALL ),
 101   mRegenerateUniformMap( 0 ),
 102   mDrawMode( DrawMode::NORMAL ),
 103   mColorMode( DEFAULT_COLOR_MODE ),
 104   mClippingMode( ClippingMode::DISABLED ),
 105   mIsRoot( false ),
 106   mIsLayer( false ),
 107   mPositionUsesAnchorPoint( true )
 108 {
 109   mUniformMapChanged[0] = 0u;
 110   mUniformMapChanged[1] = 0u;
 111
 112 #ifdef DEBUG_ENABLED
 113   gNodeCount++;
 114 #endif
 115 }
 116
 117 Node::~Node()
 118 {
 119   if( mTransformManagerData.Id() != INVALID_TRANSFORM_ID )
 120   {
 121     mTransformManagerData.Manager()->RemoveTransform(mTransformManagerData.Id());
 122   }
 123
 124 #ifdef DEBUG_ENABLED
 125   gNodeCount--;
 126 #endif
 127 }
 128
 129 void Node::OnDestroy()
 130 {
 131   // Animators, Constraints etc. should be disconnected from the child's properties.
 132   PropertyOwner::Destroy();
 133 }
 134
 135 uint32_t Node::GetId() const
 136 {
 137   return mId;
 138 }
 139
 140 void Node::CreateTransform( SceneGraph::TransformManager* transformManager )
 141 {
 142   //Create a new transform
 143   mTransformManagerData.mManager = transformManager;
 144   mTransformManagerData.mId = transformManager->CreateTransform();
 145
 146   //Initialize all the animatable properties
 147   mPosition.Initialize( &mTransformManagerData );
 148   mScale.Initialize( &mTransformManagerData );
 149   mOrientation.Initialize( &mTransformManagerData );
 150   mSize.Initialize( &mTransformManagerData );
 151   mParentOrigin.Initialize( &mTransformManagerData );
 152   mAnchorPoint.Initialize( &mTransformManagerData );
 153
 154   //Initialize all the input properties
 155   mWorldPosition.Initialize( &mTransformManagerData );
 156   mWorldScale.Initialize( &mTransformManagerData );
 157   mWorldOrientation.Initialize( &mTransformManagerData );
 158   mWorldMatrix.Initialize( &mTransformManagerData);
 159
 160   //Set whether the position should use the anchor point
 161   transformManager->SetPositionUsesAnchorPoint( mTransformManagerData.Id(), mPositionUsesAnchorPoint );
 162 }
 163
 164 void Node::SetRoot(bool isRoot)
 165 {
 166   DALI_ASSERT_DEBUG(!isRoot || mParent == NULL); // Root nodes cannot have a parent
 167
 168   mIsRoot = isRoot;
 169 }
 170
 171 void Node::AddUniformMapping(const UniformPropertyMapping& map)
 172 {
 173   PropertyOwner::AddUniformMapping( map );
 174   mRegenerateUniformMap = 2;
 175 }
 176
 177 void Node::RemoveUniformMapping( const ConstString& uniformName )
 178 {
 179   PropertyOwner::RemoveUniformMapping( uniformName );
 180   mRegenerateUniformMap = 2;
 181 }
 182
 183 bool Node::IsAnimationPossible() const
 184 {
 185   return mIsConnectedToSceneGraph;
 186 }
 187
 188 void Node::PrepareRender( BufferIndex bufferIndex )
 189 {
 190   if( mRegenerateUniformMap != 0 )
 191   {
 192     if( mRegenerateUniformMap == 2 )
 193     {
 194       CollectedUniformMap& localMap = mCollectedUniformMap[ bufferIndex ];
 195       localMap.Resize(0);
 196
 197       for( UniformMap::SizeType i = 0, count=mUniformMaps.Count(); i<count; ++i )
 198       {
 199         localMap.PushBack(mUniformMaps[i]);
 200       }
 201     }
 202     else if( mRegenerateUniformMap == 1 )
 203     {
 204       CollectedUniformMap& localMap = mCollectedUniformMap[ bufferIndex ];
 205       CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-bufferIndex ];
 206
 207       localMap.Resize( oldMap.Count() );
 208
 209       CollectedUniformMap::SizeType index = 0;
 210       for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
 211       {
 212         localMap[index] = *iter;
 213       }
 214     }
 215     --mRegenerateUniformMap;
 216     mUniformMapChanged[bufferIndex] = 1u;
 217   }
 218 }
 219
 220 void Node::ConnectChild( Node* childNode )
 221 {
 222   DALI_ASSERT_ALWAYS( this != childNode );
 223   DALI_ASSERT_ALWAYS( IsRoot() || nullptr != mParent ); // Parent should be connected first
 224   DALI_ASSERT_ALWAYS( !childNode->IsRoot() && nullptr == childNode->GetParent() ); // Child should be disconnected
 225
 226   childNode->SetParent( *this );
 227
 228   // Everything should be reinherited when reconnected to scene-graph
 229   childNode->SetAllDirtyFlags();
 230
 231   // Add the node to the end of the child list.
 232   mChildren.PushBack( childNode );
 233
 234   // Inform property observers of new connection
 235   childNode->ConnectToSceneGraph();
 236 }
 237
 238 void Node::DisconnectChild( BufferIndex updateBufferIndex, Node& childNode )
 239 {
 240   DALI_ASSERT_ALWAYS( this != &childNode );
 241   DALI_ASSERT_ALWAYS( childNode.GetParent() == this );
 242
 243   // Find the childNode and remove it
 244   Node* found( nullptr );
 245
 246   const NodeIter endIter = mChildren.End();
 247   for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter )
 248   {
 249     Node* current = *iter;
 250     if ( current == &childNode )
 251     {
 252       found = current;
 253       mChildren.Erase( iter ); // order matters here
 254       break; // iter is no longer valid
 255     }
 256   }
 257   DALI_ASSERT_ALWAYS( nullptr != found );
 258
 259   found->RecursiveDisconnectFromSceneGraph( updateBufferIndex );
 260 }
 261
 262 void Node::AddRenderer( Renderer* renderer )
 263 {
 264   // If it is the first renderer added, make sure the world transform will be calculated
 265   // in the next update as world transform is not computed if node has no renderers.
 266   if( mRenderer.Empty() )
 267   {
 268     mDirtyFlags |= NodePropertyFlags::TRANSFORM;
 269   }
 270   else
 271   {
 272     // Check that it has not been already added.
 273     for( auto&& existingRenderer : mRenderer )
 274     {
 275       if( existingRenderer == renderer )
 276       {
 277         // Renderer is already in the list.
 278         return;
 279       }
 280     }
 281   }
 282
 283   mRenderer.PushBack( renderer );
 284 }
 285
 286 void Node::RemoveRenderer( const Renderer* renderer )
 287 {
 288   RendererContainer::SizeType rendererCount( mRenderer.Size() );
 289   for( RendererContainer::SizeType i = 0; i < rendererCount; ++i )
 290   {
 291     if( mRenderer[i] == renderer )
 292     {
 293       mRenderer.Erase( mRenderer.Begin()+i);
 294       return;
 295     }
 296   }
 297 }
 298
 299 NodePropertyFlags Node::GetDirtyFlags() const
 300 {
 301   // get initial dirty flags, they are reset ResetDefaultProperties, but setters may have made the node dirty already
 302   NodePropertyFlags flags = mDirtyFlags;
 303
 304   // Check whether the visible property has changed
 305   if ( !mVisible.IsClean() )
 306   {
 307     flags |= NodePropertyFlags::VISIBLE;
 308   }
 309
 310   // Check whether the color property has changed
 311   if ( !mColor.IsClean() )
 312   {
 313     flags |= NodePropertyFlags::COLOR;
 314   }
 315
 316   return flags;
 317 }
 318
 319 NodePropertyFlags Node::GetInheritedDirtyFlags( NodePropertyFlags parentFlags ) const
 320 {
 321   // Size is not inherited. VisibleFlag is inherited
 322   static const NodePropertyFlags InheritedDirtyFlags = NodePropertyFlags::TRANSFORM | NodePropertyFlags::VISIBLE | NodePropertyFlags::COLOR;
 323   using UnderlyingType = typename std::underlying_type<NodePropertyFlags>::type;
 324
 325   return static_cast<NodePropertyFlags>( static_cast<UnderlyingType>( mDirtyFlags ) |
 326                                          ( static_cast<UnderlyingType>( parentFlags ) & static_cast<UnderlyingType>( InheritedDirtyFlags ) ) );
 327 }
 328
 329 void Node::ResetDirtyFlags( BufferIndex updateBufferIndex )
 330 {
 331   mDirtyFlags = NodePropertyFlags::NOTHING;
 332 }
 333
 334 void Node::SetParent( Node& parentNode )
 335 {
 336   DALI_ASSERT_ALWAYS(this != &parentNode);
 337   DALI_ASSERT_ALWAYS(!mIsRoot);
 338   DALI_ASSERT_ALWAYS(mParent == nullptr);
 339
 340   mParent = &parentNode;
 341
 342   if( mTransformManagerData.Id() != INVALID_TRANSFORM_ID )
 343   {
 344     mTransformManagerData.Manager()->SetParent( mTransformManagerData.Id(), parentNode.GetTransformId() );
 345   }
 346 }
 347
 348 void Node::RecursiveDisconnectFromSceneGraph( BufferIndex updateBufferIndex )
 349 {
 350   DALI_ASSERT_ALWAYS(!mIsRoot);
 351   DALI_ASSERT_ALWAYS(mParent != nullptr);
 352
 353   const NodeIter endIter = mChildren.End();
 354   for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter )
 355   {
 356     (*iter)->RecursiveDisconnectFromSceneGraph( updateBufferIndex );
 357   }
 358
 359   // Animators, Constraints etc. should be disconnected from the child's properties.
 360   PropertyOwner::DisconnectFromSceneGraph( updateBufferIndex );
 361
 362   // Remove back-pointer to parent
 363   mParent = nullptr;
 364
 365   // Remove all child pointers
 366   mChildren.Clear();
 367
 368   if( mTransformManagerData.Id() != INVALID_TRANSFORM_ID )
 369   {
 370     mTransformManagerData.Manager()->SetParent( mTransformManagerData.Id(), INVALID_TRANSFORM_ID );
 371   }
 372 }
 373
 374 } // namespace SceneGraph
 375
 376 } // namespace Internal
 377
 378 } // namespace Dali