dali/internal/update/nodes/node.cpp

   1 /*
   2  * Copyright (c) 2016 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 //Unnamed namespace
  29 {
  30 //Memory pool used to allocate new nodes. Memory used by this pool will be released when shutting down DALi
  31 Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Node> gNodeMemoryPool;
  32 }
  33
  34 namespace Dali
  35 {
  36
  37 namespace Internal
  38 {
  39
  40 namespace SceneGraph
  41 {
  42
  43 const PositionInheritanceMode Node::DEFAULT_POSITION_INHERITANCE_MODE( INHERIT_PARENT_POSITION );
  44 const ColorMode Node::DEFAULT_COLOR_MODE( USE_OWN_MULTIPLY_PARENT_ALPHA );
  45
  46 Node* Node::New()
  47 {
  48   return new ( gNodeMemoryPool.AllocateRawThreadSafe() ) Node();
  49 }
  50
  51 Node::Node()
  52 : mTransformManager(0),
  53   mTransformId( INVALID_TRANSFORM_ID ),
  54   mParentOrigin( TRANSFORM_PROPERTY_PARENT_ORIGIN ),
  55   mAnchorPoint( TRANSFORM_PROPERTY_ANCHOR_POINT ),
  56   mSize(TRANSFORM_PROPERTY_SIZE),     // zero initialized by default
  57   mPosition(TRANSFORM_PROPERTY_POSITION), // zero initialized by default
  58   mOrientation(), // initialized to identity by default
  59   mScale( TRANSFORM_PROPERTY_SCALE ),
  60   mVisible( true ),
  61   mColor( Color::WHITE ),
  62   mWorldPosition(TRANSFORM_PROPERTY_WORLD_POSITION, Vector3(0.0f,0.0f,0.0f)), // zero initialized by default
  63   mWorldScale( TRANSFORM_PROPERTY_WORLD_SCALE, Vector3(1.0f,1.0f,1.0f) ),
  64   mWorldOrientation(), // initialized to identity by default
  65   mWorldMatrix(),
  66   mWorldColor( Color::WHITE ),
  67   mParent( NULL ),
  68   mExclusiveRenderTask( NULL ),
  69   mChildren(),
  70   mRegenerateUniformMap( 0 ),
  71   mDepth(0u),
  72   mDirtyFlags(AllFlags),
  73   mIsRoot( false ),
  74   mDrawMode( DrawMode::NORMAL ),
  75   mColorMode( DEFAULT_COLOR_MODE )
  76 {
  77   mUniformMapChanged[0] = 0u;
  78   mUniformMapChanged[1] = 0u;
  79 }
  80
  81 Node::~Node()
  82 {
  83   if( mTransformId != INVALID_TRANSFORM_ID )
  84   {
  85     mTransformManager->RemoveTransform(mTransformId);
  86   }
  87 }
  88
  89 void Node::operator delete( void* ptr )
  90 {
  91   gNodeMemoryPool.FreeThreadSafe( static_cast<Node*>( ptr ) );
  92 }
  93
  94 void Node::OnDestroy()
  95 {
  96   // Animators, Constraints etc. should be disconnected from the child's properties.
  97   PropertyOwner::Destroy();
  98 }
  99
 100 void Node::CreateTransform( SceneGraph::TransformManager* transformManager )
 101 {
 102   //Create a new transform
 103   mTransformManager = transformManager;
 104   mTransformId = transformManager->CreateTransform();
 105
 106   //Initialize all the animatable properties
 107   mPosition.Initialize( transformManager, mTransformId );
 108   mScale.Initialize( transformManager, mTransformId );
 109   mOrientation.Initialize( transformManager, mTransformId );
 110   mSize.Initialize( transformManager, mTransformId );
 111   mParentOrigin.Initialize( transformManager, mTransformId );
 112   mAnchorPoint.Initialize( transformManager, mTransformId );
 113
 114   //Initialize all the input properties
 115   mWorldPosition.Initialize( transformManager, mTransformId );
 116   mWorldScale.Initialize( transformManager, mTransformId );
 117   mWorldOrientation.Initialize( transformManager, mTransformId );
 118   mWorldMatrix.Initialize( transformManager, mTransformId );
 119 }
 120
 121 void Node::SetRoot(bool isRoot)
 122 {
 123   DALI_ASSERT_DEBUG(!isRoot || mParent == NULL); // Root nodes cannot have a parent
 124
 125   mIsRoot = isRoot;
 126 }
 127
 128 void Node::AddUniformMapping( UniformPropertyMapping* map )
 129 {
 130   PropertyOwner::AddUniformMapping( map );
 131   mRegenerateUniformMap = 2;
 132 }
 133
 134 void Node::RemoveUniformMapping( const std::string& uniformName )
 135 {
 136   PropertyOwner::RemoveUniformMapping( uniformName );
 137   mRegenerateUniformMap = 2;
 138 }
 139
 140 void Node::PrepareRender( BufferIndex bufferIndex )
 141 {
 142   if(mRegenerateUniformMap != 0 )
 143   {
 144     if( mRegenerateUniformMap == 2 )
 145     {
 146       CollectedUniformMap& localMap = mCollectedUniformMap[ bufferIndex ];
 147       localMap.Resize(0);
 148
 149       for( unsigned int i=0, count=mUniformMaps.Count(); i<count; ++i )
 150       {
 151         localMap.PushBack( &mUniformMaps[i] );
 152       }
 153     }
 154     else if( mRegenerateUniformMap == 1 )
 155     {
 156       CollectedUniformMap& localMap = mCollectedUniformMap[ bufferIndex ];
 157       CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-bufferIndex ];
 158
 159       localMap.Resize( oldMap.Count() );
 160
 161       unsigned int index=0;
 162       for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
 163       {
 164         localMap[index] = *iter;
 165       }
 166     }
 167     --mRegenerateUniformMap;
 168     mUniformMapChanged[bufferIndex] = 1u;
 169   }
 170 }
 171
 172 void Node::ConnectChild( Node* childNode )
 173 {
 174   DALI_ASSERT_ALWAYS( this != childNode );
 175   DALI_ASSERT_ALWAYS( IsRoot() || NULL != mParent ); // Parent should be connected first
 176   DALI_ASSERT_ALWAYS( !childNode->IsRoot() && NULL == childNode->GetParent() ); // Child should be disconnected
 177
 178   childNode->SetParent( *this );
 179
 180   // Everything should be reinherited when reconnected to scene-graph
 181   childNode->SetAllDirtyFlags();
 182
 183   // Add the node to the end of the child list.
 184   mChildren.PushBack( childNode );
 185
 186   // Inform property observers of new connection
 187   childNode->ConnectToSceneGraph();
 188 }
 189
 190 void Node::DisconnectChild( BufferIndex updateBufferIndex, Node& childNode )
 191 {
 192   DALI_ASSERT_ALWAYS( this != &childNode );
 193   DALI_ASSERT_ALWAYS( childNode.GetParent() == this );
 194
 195   // Find the childNode and remove it
 196   Node* found( NULL );
 197
 198   const NodeIter endIter = mChildren.End();
 199   for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter )
 200   {
 201     Node* current = *iter;
 202     if ( current == &childNode )
 203     {
 204       found = current;
 205       mChildren.Erase( iter ); // order matters here
 206       break; // iter is no longer valid
 207     }
 208   }
 209   DALI_ASSERT_ALWAYS( NULL != found );
 210
 211   found->RecursiveDisconnectFromSceneGraph( updateBufferIndex );
 212 }
 213
 214 void Node::RemoveRenderer( Renderer* renderer )
 215 {
 216   unsigned int rendererCount( mRenderer.Size() );
 217   for( unsigned int i(0); i<rendererCount; ++i )
 218   {
 219     if( mRenderer[i] == renderer )
 220     {
 221       mRenderer.Erase( mRenderer.Begin()+i);
 222       return;
 223     }
 224   }
 225 }
 226
 227 int Node::GetDirtyFlags() const
 228 {
 229   // get initial dirty flags, they are reset ResetDefaultProperties, but setters may have made the node dirty already
 230   int flags = mDirtyFlags;
 231
 232   // Check whether the visible property has changed
 233   if ( !mVisible.IsClean() )
 234   {
 235     flags |= VisibleFlag;
 236   }
 237
 238   // Check whether the color property has changed
 239   if ( !mColor.IsClean() )
 240   {
 241     flags |= ColorFlag;
 242   }
 243
 244   return flags;
 245 }
 246
 247 void Node::ResetDefaultProperties( BufferIndex updateBufferIndex )
 248 {
 249   mVisible.ResetToBaseValue( updateBufferIndex );
 250   mColor.ResetToBaseValue( updateBufferIndex );
 251
 252   mDirtyFlags = NothingFlag;
 253 }
 254
 255 void Node::SetParent(Node& parentNode)
 256 {
 257   DALI_ASSERT_ALWAYS(this != &parentNode);
 258   DALI_ASSERT_ALWAYS(!mIsRoot);
 259   DALI_ASSERT_ALWAYS(mParent == NULL);
 260
 261   mParent = &parentNode;
 262   mDepth = mParent->GetDepth() + 1u;
 263
 264   if( mTransformId != INVALID_TRANSFORM_ID )
 265   {
 266     mTransformManager->SetParent( mTransformId, parentNode.GetTransformId() );
 267   }
 268 }
 269
 270 void Node::RecursiveDisconnectFromSceneGraph( BufferIndex updateBufferIndex )
 271 {
 272   DALI_ASSERT_ALWAYS(!mIsRoot);
 273   DALI_ASSERT_ALWAYS(mParent != NULL);
 274
 275   const NodeIter endIter = mChildren.End();
 276   for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter )
 277   {
 278     (*iter)->RecursiveDisconnectFromSceneGraph( updateBufferIndex );
 279   }
 280
 281   // Animators, Constraints etc. should be disconnected from the child's properties.
 282   PropertyOwner::DisconnectFromSceneGraph( updateBufferIndex );
 283
 284   // Remove back-pointer to parent
 285   mParent = NULL;
 286   mDepth = 0u;
 287
 288   // Remove all child pointers
 289   mChildren.Clear();
 290
 291   if( mTransformId != INVALID_TRANSFORM_ID )
 292   {
 293     mTransformManager->SetParent( mTransformId, INVALID_TRANSFORM_ID );
 294   }
 295 }
 296
 297 } // namespace SceneGraph
 298
 299 } // namespace Internal
 300
 301 } // namespace Dali