X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fnodes%2Fnode.cpp;h=20d7aaac2016dabfd7143621d6528dc188ed220d;hb=857999ccc4786403ee174a361a5d3d7e250435b7;hp=32f6dee8d74080ae506aa3b406c82635c41c6882;hpb=881debaa847c90abd86092c8dad4375c08a8f8c4;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/nodes/node.cpp b/dali/internal/update/nodes/node.cpp old mode 100755 new mode 100644 index 32f6dee..20d7aaa --- a/dali/internal/update/nodes/node.cpp +++ b/dali/internal/update/nodes/node.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * Copyright (c) 2021 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. @@ -22,8 +22,8 @@ #include #include #include -#include #include +#include namespace { @@ -35,41 +35,38 @@ Dali::Internal::MemoryPoolObjectAllocator gNod int32_t gNodeCount = 0; // Called when the process is about to exit, Node count should be zero at this point. -void __attribute__ ((destructor)) ShutDown(void) +void __attribute__((destructor)) ShutDown(void) { -DALI_ASSERT_DEBUG( (gNodeCount == 0) && "Node memory leak"); + DALI_ASSERT_DEBUG((gNodeCount == 0) && "Node memory leak"); } #endif } // Unnamed namespace namespace Dali { - namespace Internal { - namespace SceneGraph { +const ColorMode Node::DEFAULT_COLOR_MODE(USE_OWN_MULTIPLY_PARENT_ALPHA); -const ColorMode Node::DEFAULT_COLOR_MODE( USE_OWN_MULTIPLY_PARENT_ALPHA ); - -uint32_t Node::mNodeCounter = 0; ///< A counter to provide unique node ids, up-to 4 billion +uint32_t Node::mNodeCounter = 0; ///< A counter to provide unique node ids, up-to 4 billion Node* Node::New() { - return new ( gNodeMemoryPool.AllocateRawThreadSafe() ) Node; + return new(gNodeMemoryPool.AllocateRawThreadSafe()) Node; } -void Node::Delete( Node* node ) +void Node::Delete(Node* node) { // check we have a node not a layer - if( !node->mIsLayer ) + if(!node->mIsLayer) { // Manually call the destructor node->~Node(); // Mark the memory it used as free in the memory pool - gNodeMemoryPool.FreeThreadSafe( node ); + gNodeMemoryPool.FreeThreadSafe(node); } else { @@ -79,39 +76,33 @@ void Node::Delete( Node* node ) } Node::Node() -: mTransformManager( NULL ), - mTransformId( INVALID_TRANSFORM_ID ), - mParentOrigin( TRANSFORM_PROPERTY_PARENT_ORIGIN ), - mAnchorPoint( TRANSFORM_PROPERTY_ANCHOR_POINT ), - mSize( TRANSFORM_PROPERTY_SIZE ), // Zero initialized by default - mPosition( TRANSFORM_PROPERTY_POSITION ), // Zero initialized by default - mOrientation(), // Initialized to identity by default - mScale( TRANSFORM_PROPERTY_SCALE ), - mVisible( true ), - mCulled( false ), - mColor( Color::WHITE ), - mUpdateSizeHint( Vector3::ZERO ), - 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 +: mOrientation(), // Initialized to identity by default + mVisible(true), + mCulled(false), + mColor(Color::WHITE), + mUpdateSizeHint(Vector3::ZERO), + 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(), - mWorldColor( Color::WHITE ), - mClippingSortModifier( 0u ), - mId( ++mNodeCounter ), - mParent( NULL ), - mExclusiveRenderTask( NULL ), + mWorldColor(Color::WHITE), + mClippingSortModifier(0u), + mId(++mNodeCounter), + mParent(nullptr), + mExclusiveRenderTask(nullptr), mChildren(), - mClippingDepth( 0u ), - mScissorDepth( 0u ), - mDepthIndex( 0u ), - mDirtyFlags( NodePropertyFlags::ALL ), - mRegenerateUniformMap( 0 ), - mDrawMode( DrawMode::NORMAL ), - mColorMode( DEFAULT_COLOR_MODE ), - mClippingMode( ClippingMode::DISABLED ), - mIsRoot( false ), - mIsLayer( false ), - mPositionUsesAnchorPoint( true ) + mClippingDepth(0u), + mScissorDepth(0u), + mDepthIndex(0u), + mDirtyFlags(NodePropertyFlags::ALL), + mRegenerateUniformMap(0), + mDrawMode(DrawMode::NORMAL), + mColorMode(DEFAULT_COLOR_MODE), + mClippingMode(ClippingMode::DISABLED), + mIsRoot(false), + mIsLayer(false), + mPositionUsesAnchorPoint(true), + mTransparent(false) { mUniformMapChanged[0] = 0u; mUniformMapChanged[1] = 0u; @@ -119,16 +110,18 @@ Node::Node() #ifdef DEBUG_ENABLED gNodeCount++; #endif - } Node::~Node() { - if( mTransformId != INVALID_TRANSFORM_ID ) + if(mTransformManagerData.Id() != INVALID_TRANSFORM_ID) { - mTransformManager->RemoveTransform(mTransformId); + mTransformManagerData.Manager()->RemoveTransform(mTransformManagerData.Id()); } + // For debugging + mDepthIndex = 0xABABABAB; + #ifdef DEBUG_ENABLED gNodeCount--; #endif @@ -145,28 +138,28 @@ uint32_t Node::GetId() const return mId; } -void Node::CreateTransform( SceneGraph::TransformManager* transformManager ) +void Node::CreateTransform(SceneGraph::TransformManager* transformManager) { //Create a new transform - mTransformManager = transformManager; - mTransformId = transformManager->CreateTransform(); + mTransformManagerData.mManager = transformManager; + mTransformManagerData.mId = transformManager->CreateTransform(); //Initialize all the animatable properties - mPosition.Initialize( transformManager, mTransformId ); - mScale.Initialize( transformManager, mTransformId ); - mOrientation.Initialize( transformManager, mTransformId ); - mSize.Initialize( transformManager, mTransformId ); - mParentOrigin.Initialize( transformManager, mTransformId ); - mAnchorPoint.Initialize( transformManager, mTransformId ); + 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( transformManager, mTransformId ); - mWorldScale.Initialize( transformManager, mTransformId ); - mWorldOrientation.Initialize( transformManager, mTransformId ); - mWorldMatrix.Initialize( transformManager, mTransformId ); + mWorldPosition.Initialize(&mTransformManagerData); + mWorldScale.Initialize(&mTransformManagerData); + mWorldOrientation.Initialize(&mTransformManagerData); + mWorldMatrix.Initialize(&mTransformManagerData); //Set whether the position should use the anchor point - transformManager->SetPositionUsesAnchorPoint( mTransformId, mPositionUsesAnchorPoint ); + transformManager->SetPositionUsesAnchorPoint(mTransformManagerData.Id(), mPositionUsesAnchorPoint); } void Node::SetRoot(bool isRoot) @@ -176,41 +169,46 @@ void Node::SetRoot(bool isRoot) mIsRoot = isRoot; } -void Node::AddUniformMapping( OwnerPointer< UniformPropertyMapping >& map ) +void Node::AddUniformMapping(const UniformPropertyMapping& map) { - PropertyOwner::AddUniformMapping( map ); + PropertyOwner::AddUniformMapping(map); mRegenerateUniformMap = 2; } -void Node::RemoveUniformMapping( const std::string& uniformName ) +void Node::RemoveUniformMapping(const ConstString& uniformName) { - PropertyOwner::RemoveUniformMapping( uniformName ); + PropertyOwner::RemoveUniformMapping(uniformName); mRegenerateUniformMap = 2; } -void Node::PrepareRender( BufferIndex bufferIndex ) +bool Node::IsAnimationPossible() const +{ + return mIsConnectedToSceneGraph; +} + +void Node::PrepareRender(BufferIndex bufferIndex) { - if( mRegenerateUniformMap != 0 ) + if(mRegenerateUniformMap != 0) { - if( mRegenerateUniformMap == 2 ) + if(mRegenerateUniformMap == 2) { - CollectedUniformMap& localMap = mCollectedUniformMap[ bufferIndex ]; + CollectedUniformMap& localMap = mCollectedUniformMap[bufferIndex]; localMap.Resize(0); - for( UniformMap::SizeType i = 0, count=mUniformMaps.Count(); iIsRoot() && NULL == childNode->GetParent() ); // Child should be disconnected + DALI_ASSERT_ALWAYS(this != childNode); + DALI_ASSERT_ALWAYS(IsRoot() || nullptr != mParent); // Parent should be connected first + DALI_ASSERT_ALWAYS(!childNode->IsRoot() && nullptr == childNode->GetParent()); // Child should be disconnected - childNode->SetParent( *this ); + childNode->SetParent(*this); // Everything should be reinherited when reconnected to scene-graph childNode->SetAllDirtyFlags(); // Add the node to the end of the child list. - mChildren.PushBack( childNode ); + mChildren.PushBack(childNode); // Inform property observers of new connection childNode->ConnectToSceneGraph(); } -void Node::DisconnectChild( BufferIndex updateBufferIndex, Node& childNode ) +void Node::DisconnectChild(BufferIndex updateBufferIndex, Node& childNode) { - DALI_ASSERT_ALWAYS( this != &childNode ); - DALI_ASSERT_ALWAYS( childNode.GetParent() == this ); + DALI_ASSERT_ALWAYS(this != &childNode); + DALI_ASSERT_ALWAYS(childNode.GetParent() == this); // Find the childNode and remove it - Node* found( NULL ); + Node* found(nullptr); const NodeIter endIter = mChildren.End(); - for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter ) + for(NodeIter iter = mChildren.Begin(); iter != endIter; ++iter) { Node* current = *iter; - if ( current == &childNode ) + if(current == &childNode) { found = current; - mChildren.Erase( iter ); // order matters here - break; // iter is no longer valid + mChildren.Erase(iter); // order matters here + break; // iter is no longer valid } } - DALI_ASSERT_ALWAYS( NULL != found ); + DALI_ASSERT_ALWAYS(nullptr != found); - found->RecursiveDisconnectFromSceneGraph( updateBufferIndex ); + found->RecursiveDisconnectFromSceneGraph(updateBufferIndex); } -void Node::AddRenderer( Renderer* renderer ) +void Node::AddRenderer(Renderer* 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(mRenderer.Empty()) { mDirtyFlags |= NodePropertyFlags::TRANSFORM; } else { // Check that it has not been already added. - for( auto&& existingRenderer : mRenderer ) + for(auto&& existingRenderer : mRenderer) { - if( existingRenderer == renderer ) + if(existingRenderer == renderer) { // Renderer is already in the list. return; @@ -283,17 +281,17 @@ void Node::AddRenderer( Renderer* renderer ) } } - mRenderer.PushBack( renderer ); + mRenderer.PushBack(renderer); } -void Node::RemoveRenderer( const Renderer* renderer ) +void Node::RemoveRenderer(const Renderer* renderer) { - RendererContainer::SizeType rendererCount( mRenderer.Size() ); - for( RendererContainer::SizeType i = 0; i < rendererCount; ++i ) + RendererContainer::SizeType rendererCount(mRenderer.Size()); + for(RendererContainer::SizeType i = 0; i < rendererCount; ++i) { - if( mRenderer[i] == renderer ) + if(mRenderer[i] == renderer) { - mRenderer.Erase( mRenderer.Begin()+i); + mRenderer.Erase(mRenderer.Begin() + i); return; } } @@ -305,13 +303,13 @@ NodePropertyFlags Node::GetDirtyFlags() const NodePropertyFlags flags = mDirtyFlags; // Check whether the visible property has changed - if ( !mVisible.IsClean() ) + if(!mVisible.IsClean()) { flags |= NodePropertyFlags::VISIBLE; } // Check whether the color property has changed - if ( !mColor.IsClean() ) + if(!mColor.IsClean()) { flags |= NodePropertyFlags::COLOR; } @@ -319,58 +317,58 @@ NodePropertyFlags Node::GetDirtyFlags() const return flags; } -NodePropertyFlags Node::GetInheritedDirtyFlags( NodePropertyFlags parentFlags ) const +NodePropertyFlags Node::GetInheritedDirtyFlags(NodePropertyFlags parentFlags) const { // Size is not inherited. VisibleFlag is inherited static const NodePropertyFlags InheritedDirtyFlags = NodePropertyFlags::TRANSFORM | NodePropertyFlags::VISIBLE | NodePropertyFlags::COLOR; - using UnderlyingType = typename std::underlying_type::type; + using UnderlyingType = typename std::underlying_type::type; - return static_cast( static_cast( mDirtyFlags ) | - ( static_cast( parentFlags ) & static_cast( InheritedDirtyFlags ) ) ); + return static_cast(static_cast(mDirtyFlags) | + (static_cast(parentFlags) & static_cast(InheritedDirtyFlags))); } -void Node::ResetDirtyFlags( BufferIndex updateBufferIndex ) +void Node::ResetDirtyFlags(BufferIndex updateBufferIndex) { mDirtyFlags = NodePropertyFlags::NOTHING; } -void Node::SetParent( Node& parentNode ) +void Node::SetParent(Node& parentNode) { DALI_ASSERT_ALWAYS(this != &parentNode); DALI_ASSERT_ALWAYS(!mIsRoot); - DALI_ASSERT_ALWAYS(mParent == NULL); + DALI_ASSERT_ALWAYS(mParent == nullptr); mParent = &parentNode; - if( mTransformId != INVALID_TRANSFORM_ID ) + if(mTransformManagerData.Id() != INVALID_TRANSFORM_ID) { - mTransformManager->SetParent( mTransformId, parentNode.GetTransformId() ); + mTransformManagerData.Manager()->SetParent(mTransformManagerData.Id(), parentNode.GetTransformId()); } } -void Node::RecursiveDisconnectFromSceneGraph( BufferIndex updateBufferIndex ) +void Node::RecursiveDisconnectFromSceneGraph(BufferIndex updateBufferIndex) { DALI_ASSERT_ALWAYS(!mIsRoot); - DALI_ASSERT_ALWAYS(mParent != NULL); + DALI_ASSERT_ALWAYS(mParent != nullptr); const NodeIter endIter = mChildren.End(); - for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter ) + for(NodeIter iter = mChildren.Begin(); iter != endIter; ++iter) { - (*iter)->RecursiveDisconnectFromSceneGraph( updateBufferIndex ); + (*iter)->RecursiveDisconnectFromSceneGraph(updateBufferIndex); } // Animators, Constraints etc. should be disconnected from the child's properties. - PropertyOwner::DisconnectFromSceneGraph( updateBufferIndex ); + PropertyOwner::DisconnectFromSceneGraph(updateBufferIndex); // Remove back-pointer to parent - mParent = NULL; + mParent = nullptr; // Remove all child pointers mChildren.Clear(); - if( mTransformId != INVALID_TRANSFORM_ID ) + if(mTransformManagerData.Id() != INVALID_TRANSFORM_ID) { - mTransformManager->SetParent( mTransformId, INVALID_TRANSFORM_ID ); + mTransformManagerData.Manager()->SetParent(mTransformManagerData.Id(), INVALID_TRANSFORM_ID); } }