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 : mTransformManager( NULL ),
  83   mTransformId( INVALID_TRANSFORM_ID ),
  84   mParentOrigin( TRANSFORM_PROPERTY_PARENT_ORIGIN ),
  85   mAnchorPoint( TRANSFORM_PROPERTY_ANCHOR_POINT ),
  86   mSize( TRANSFORM_PROPERTY_SIZE ),                                               // Zero initialized by default
  87   mPosition( TRANSFORM_PROPERTY_POSITION ),                                       // Zero initialized by default
  88   mOrientation(),                                                                 // Initialized to identity by default
  89   mScale( TRANSFORM_PROPERTY_SCALE ),
  90   mUpdateSizeHint( TRANSFORM_PROPERTY_UPDATE_SIZE_HINT ),
  91   mVisible( true ),
  92   mCulled( false ),
  93   mColor( Color::WHITE ),
  94   mWorldPosition( TRANSFORM_PROPERTY_WORLD_POSITION, Vector3( 0.0f,0.0f,0.0f ) ), // Zero initialized by default
  95   mWorldScale( TRANSFORM_PROPERTY_WORLD_SCALE, Vector3( 1.0f,1.0f,1.0f ) ),
  96   mWorldOrientation(),                                                            // Initialized to identity by default
  97   mWorldMatrix(),
  98   mWorldColor( Color::WHITE ),
  99   mClippingSortModifier( 0u ),
 100   mId( ++mNodeCounter ),
 101   mParent( NULL ),
 102   mExclusiveRenderTask( NULL ),
 103   mChildren(),
 104   mClippingDepth( 0u ),
 105   mScissorDepth( 0u ),
 106   mDepthIndex( 0u ),
 107   mDirtyFlags( NodePropertyFlags::ALL ),
 108   mRegenerateUniformMap( 0 ),
 109   mDrawMode( DrawMode::NORMAL ),
 110   mColorMode( DEFAULT_COLOR_MODE ),
 111   mClippingMode( ClippingMode::DISABLED ),
 112   mIsRoot( false ),
 113   mIsLayer( false ),
 114   mPositionUsesAnchorPoint( true ),
 115   mPartialUpdateAvailable( false )
 116 {
 117   mUniformMapChanged[0] = 0u;
 118   mUniformMapChanged[1] = 0u;
 119   mPropertyDirty = true;
 120
 121 #ifdef DEBUG_ENABLED
 122   gNodeCount++;
 123 #endif
 124
 125 }
 126
 127 Node::~Node()
 128 {
 129   if( mTransformId != INVALID_TRANSFORM_ID )
 130   {
 131     mTransformManager->RemoveTransform(mTransformId);
 132   }
 133
 134 #ifdef DEBUG_ENABLED
 135   gNodeCount--;
 136 #endif
 137 }
 138
 139 void Node::OnDestroy()
 140 {
 141   // Animators, Constraints etc. should be disconnected from the child's properties.
 142   PropertyOwner::Destroy();
 143 }
 144
 145 uint32_t Node::GetId() const
 146 {
 147   return mId;
 148 }
 149
 150 void Node::CreateTransform( SceneGraph::TransformManager* transformManager )
 151 {
 152   //Create a new transform
 153   mTransformManager = transformManager;
 154   mTransformId = transformManager->CreateTransform();
 155
 156   //Initialize all the animatable properties
 157   mPosition.Initialize( transformManager, mTransformId );
 158   mScale.Initialize( transformManager, mTransformId );
 159   mUpdateSizeHint.Initialize( transformManager, mTransformId );
 160   mOrientation.Initialize( transformManager, mTransformId );
 161   mSize.Initialize( transformManager, mTransformId );
 162   mParentOrigin.Initialize( transformManager, mTransformId );
 163   mAnchorPoint.Initialize( transformManager, mTransformId );
 164
 165   //Initialize all the input properties
 166   mWorldPosition.Initialize( transformManager, mTransformId );
 167   mWorldScale.Initialize( transformManager, mTransformId );
 168   mWorldOrientation.Initialize( transformManager, mTransformId );
 169   mWorldMatrix.Initialize( transformManager, mTransformId );
 170
 171   //Set whether the position should use the anchor point
 172   transformManager->SetPositionUsesAnchorPoint( mTransformId, mPositionUsesAnchorPoint );
 173 }
 174
 175 void Node::SetRoot(bool isRoot)
 176 {
 177   DALI_ASSERT_DEBUG(!isRoot || mParent == NULL); // Root nodes cannot have a parent
 178
 179   mIsRoot = isRoot;
 180 }
 181
 182 void Node::AddUniformMapping( OwnerPointer< UniformPropertyMapping >& map )
 183 {
 184   PropertyOwner::AddUniformMapping( map );
 185   mRegenerateUniformMap = 2;
 186 }
 187
 188 void Node::RemoveUniformMapping( const std::string& uniformName )
 189 {
 190   PropertyOwner::RemoveUniformMapping( uniformName );
 191   mRegenerateUniformMap = 2;
 192 }
 193
 194 void Node::PrepareRender( BufferIndex bufferIndex )
 195 {
 196   if( mRegenerateUniformMap != 0 )
 197   {
 198     if( mRegenerateUniformMap == 2 )
 199     {
 200       CollectedUniformMap& localMap = mCollectedUniformMap[ bufferIndex ];
 201       localMap.Resize(0);
 202
 203       for( UniformMap::SizeType i = 0, count=mUniformMaps.Count(); i<count; ++i )
 204       {
 205         localMap.PushBack( &mUniformMaps[i] );
 206       }
 207     }
 208     else if( mRegenerateUniformMap == 1 )
 209     {
 210       CollectedUniformMap& localMap = mCollectedUniformMap[ bufferIndex ];
 211       CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-bufferIndex ];
 212
 213       localMap.Resize( oldMap.Count() );
 214
 215       CollectedUniformMap::SizeType index = 0;
 216       for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
 217       {
 218         localMap[index] = *iter;
 219       }
 220     }
 221     --mRegenerateUniformMap;
 222     mUniformMapChanged[bufferIndex] = 1u;
 223   }
 224 }
 225
 226 void Node::ConnectChild( Node* childNode )
 227 {
 228   DALI_ASSERT_ALWAYS( this != childNode );
 229   DALI_ASSERT_ALWAYS( IsRoot() || NULL != mParent ); // Parent should be connected first
 230   DALI_ASSERT_ALWAYS( !childNode->IsRoot() && NULL == childNode->GetParent() ); // Child should be disconnected
 231
 232   childNode->SetParent( *this );
 233
 234   // Everything should be reinherited when reconnected to scene-graph
 235   childNode->SetAllDirtyFlags();
 236
 237   // Add the node to the end of the child list.
 238   mChildren.PushBack( childNode );
 239
 240   // Inform property observers of new connection
 241   childNode->ConnectToSceneGraph();
 242 }
 243
 244 void Node::DisconnectChild( BufferIndex updateBufferIndex, Node& childNode )
 245 {
 246   DALI_ASSERT_ALWAYS( this != &childNode );
 247   DALI_ASSERT_ALWAYS( childNode.GetParent() == this );
 248
 249   // Find the childNode and remove it
 250   Node* found( NULL );
 251
 252   const NodeIter endIter = mChildren.End();
 253   for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter )
 254   {
 255     Node* current = *iter;
 256     if ( current == &childNode )
 257     {
 258       found = current;
 259       mChildren.Erase( iter ); // order matters here
 260       break; // iter is no longer valid
 261     }
 262   }
 263   DALI_ASSERT_ALWAYS( NULL != found );
 264
 265   found->RecursiveDisconnectFromSceneGraph( updateBufferIndex );
 266 }
 267
 268 void Node::AddRenderer( Renderer* renderer )
 269 {
 270   // If it is the first renderer added, make sure the world transform will be calculated
 271   // in the next update as world transform is not computed if node has no renderers.
 272   if( mRenderer.Empty() )
 273   {
 274     mDirtyFlags |= NodePropertyFlags::TRANSFORM;
 275   }
 276   else
 277   {
 278     // Check that it has not been already added.
 279     for( auto&& existingRenderer : mRenderer )
 280     {
 281       if( existingRenderer == renderer )
 282       {
 283         // Renderer is already in the list.
 284         return;
 285       }
 286     }
 287   }
 288
 289   mRenderer.PushBack( renderer );
 290   SetPropertyDirty( true );
 291 }
 292
 293
 294 void Node::RemoveRenderer( const Renderer* renderer )
 295 {
 296   Node *parent = mIsRoot ? NULL : GetParent();
 297   RendererContainer::SizeType rendererCount( mRenderer.Size() );
 298   for( RendererContainer::SizeType i = 0; i < rendererCount; ++i )
 299   {
 300     if( mRenderer[i] == renderer )
 301     {
 302       if( parent != NULL )
 303       {
 304         parent->mPropertyDirty = true;
 305       }
 306       SetPropertyDirty( true );
 307       mRenderer.Erase( mRenderer.Begin()+i);
 308       return;
 309     }
 310   }
 311 }
 312
 313 NodePropertyFlags Node::GetDirtyFlags() const
 314 {
 315   // get initial dirty flags, they are reset ResetDefaultProperties, but setters may have made the node dirty already
 316   NodePropertyFlags flags = mDirtyFlags;
 317
 318   // Check whether the visible property has changed
 319   if ( !mVisible.IsClean() )
 320   {
 321     flags |= NodePropertyFlags::VISIBLE;
 322   }
 323
 324   // Check whether the color property has changed
 325   if ( !mColor.IsClean() )
 326   {
 327     flags |= NodePropertyFlags::COLOR;
 328   }
 329
 330   return flags;
 331 }
 332
 333 NodePropertyFlags Node::GetInheritedDirtyFlags( NodePropertyFlags parentFlags ) const
 334 {
 335   // Size is not inherited. VisibleFlag is inherited
 336   static const NodePropertyFlags InheritedDirtyFlags = NodePropertyFlags::TRANSFORM | NodePropertyFlags::VISIBLE | NodePropertyFlags::COLOR;
 337   using UnderlyingType = typename std::underlying_type<NodePropertyFlags>::type;
 338
 339   return static_cast<NodePropertyFlags>( static_cast<UnderlyingType>( mDirtyFlags ) |
 340                                          ( static_cast<UnderlyingType>( parentFlags ) & static_cast<UnderlyingType>( InheritedDirtyFlags ) ) );
 341 }
 342
 343 void Node::ResetDirtyFlags( BufferIndex updateBufferIndex )
 344 {
 345   mDirtyFlags = NodePropertyFlags::NOTHING;
 346
 347   SetPropertyDirty( false );
 348
 349 }
 350
 351 void Node::SetParent( Node& parentNode )
 352 {
 353   DALI_ASSERT_ALWAYS(this != &parentNode);
 354   DALI_ASSERT_ALWAYS(!mIsRoot);
 355   DALI_ASSERT_ALWAYS(mParent == NULL);
 356
 357   mParent = &parentNode;
 358
 359   if( mTransformId != INVALID_TRANSFORM_ID )
 360   {
 361     mTransformManager->SetParent( mTransformId, parentNode.GetTransformId() );
 362   }
 363 }
 364
 365 void Node::RecursiveDisconnectFromSceneGraph( BufferIndex updateBufferIndex )
 366 {
 367   DALI_ASSERT_ALWAYS(!mIsRoot);
 368   DALI_ASSERT_ALWAYS(mParent != NULL);
 369
 370   const NodeIter endIter = mChildren.End();
 371   for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter )
 372   {
 373     (*iter)->RecursiveDisconnectFromSceneGraph( updateBufferIndex );
 374   }
 375
 376   // Animators, Constraints etc. should be disconnected from the child's properties.
 377   PropertyOwner::DisconnectFromSceneGraph( updateBufferIndex );
 378
 379   // Remove back-pointer to parent
 380   mParent = NULL;
 381
 382   // Remove all child pointers
 383   mChildren.Clear();
 384
 385   if( mTransformId != INVALID_TRANSFORM_ID )
 386   {
 387     mTransformManager->SetParent( mTransformId, INVALID_TRANSFORM_ID );
 388   }
 389 }
 390 void Node::SetPartialUpdateAvailable( bool value )
 391 {
 392   mPartialUpdateAvailable = value;
 393 }
 394
 395 bool Node::IsPartialUpdateAvailable() const
 396 {
 397   return mPartialUpdateAvailable;
 398 }
 399
 400 void Node::SetPropertyDirty( bool value )
 401 {
 402   if( mPartialUpdateAvailable )
 403   {
 404     mPropertyDirty = value;
 405
 406     const NodeIter endIter = mChildren.End();
 407     for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter )
 408     {
 409       Node* current = *iter;
 410       current->SetPropertyDirty( value );
 411     }
 412   }
 413 }
 414
 415 bool Node::IsPropertyDirty() const
 416 {
 417   if( mPartialUpdateAvailable )
 418   {
 419     if( !mPropertyDirty )
 420     {
 421       for( auto&& existingRenderer : mRenderer )
 422       {
 423         if( existingRenderer->IsDirty() )
 424         {
 425           return true;
 426         }
 427       }
 428     }
 429   }
 430   return mPropertyDirty;
 431 }
 432
 433 } // namespace SceneGraph
 434
 435 } // namespace Internal
 436
 437 } // namespace Dali