X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fnodes%2Fnode.cpp;h=aa7f77735afa053565bb3cafa190998f26f0a9e3;hb=0643c768fd100bd7ffb522e3358b88d075bc1d2e;hp=52fad10689edc98770873f5634a872c46e86ba86;hpb=21ad0307d423d39fd376eafd67fb4963c0f040cc;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/nodes/node.cpp b/dali/internal/update/nodes/node.cpp index 52fad10..aa7f777 100644 --- a/dali/internal/update/nodes/node.cpp +++ b/dali/internal/update/nodes/node.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2018 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. @@ -21,15 +21,25 @@ // INTERNAL INCLUDES #include #include -#include #include #include #include namespace //Unnamed namespace { -//Memory pool used to allocate new nodes. Memory used by this pool will be released when shutting down DALi +//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 gNodeMemoryPool; +#ifdef DEBUG_ENABLED +// keep track of nodes created / deleted, to ensure we have 0 when the process exits or DALi library is unloaded +int gNodeCount =0; + +// Called when the process is about to exit, Node count should be zero at this point. +void __attribute__ ((destructor)) ShutDown(void) +{ +DALI_ASSERT_DEBUG( (gNodeCount == 0) && "Node memory leak"); +} +#endif } namespace Dali @@ -44,75 +54,111 @@ namespace SceneGraph const PositionInheritanceMode Node::DEFAULT_POSITION_INHERITANCE_MODE( INHERIT_PARENT_POSITION ); const ColorMode Node::DEFAULT_COLOR_MODE( USE_OWN_MULTIPLY_PARENT_ALPHA ); + Node* Node::New() { return new ( gNodeMemoryPool.AllocateRawThreadSafe() ) Node(); } +void Node::Delete( Node* node ) +{ + // check we have a node not a layer + if( !node->mIsLayer ) + { + // Manually call the destructor + node->~Node(); + + // Mark the memory it used as free in the memory pool + gNodeMemoryPool.FreeThreadSafe( node ); + } + else + { + // not in the pool, just delete it. + delete node; + } +} + Node::Node() -: mParentOrigin( ParentOrigin::DEFAULT ), - mAnchorPoint( AnchorPoint::DEFAULT ), - mSize(), // zero initialized by default - mPosition(), // zero initialized by default - mOrientation(), // initialized to identity by default - mScale( Vector3::ONE ), +: 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 ), mColor( Color::WHITE ), - mWorldPosition(), // zero initialized by default - mWorldOrientation(), // initialized to identity by default - mWorldScale( Vector3::ONE ), + 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 ), mParent( NULL ), mExclusiveRenderTask( NULL ), - mAttachment( NULL ), mChildren(), + mClippingDepth( 0u ), + mScissorDepth( 0u ), + mDepthIndex( 0u ), mRegenerateUniformMap( 0 ), - mDepth(0u), - mDirtyFlags(AllFlags), - mIsRoot( false ), - mInheritPosition( true ), - mInheritOrientation( true ), - mInheritScale( true ), + mDirtyFlags( AllFlags ), mDrawMode( DrawMode::NORMAL ), - mPositionInheritanceMode( DEFAULT_POSITION_INHERITANCE_MODE ), - mColorMode( DEFAULT_COLOR_MODE ) + mColorMode( DEFAULT_COLOR_MODE ), + mClippingMode( ClippingMode::DISABLED ), + mIsRoot( false ), + mIsLayer( false ), + mPositionUsesAnchorPoint( true ) { mUniformMapChanged[0] = 0u; mUniformMapChanged[1] = 0u; + +#ifdef DEBUG_ENABLED + gNodeCount++; +#endif + } Node::~Node() { -} + if( mTransformId != INVALID_TRANSFORM_ID ) + { + mTransformManager->RemoveTransform(mTransformId); + } -void Node::operator delete( void* ptr ) -{ - gNodeMemoryPool.FreeThreadSafe( static_cast( ptr ) ); +#ifdef DEBUG_ENABLED + gNodeCount--; +#endif } void Node::OnDestroy() { - // Node attachments should be notified about the disconnection. - if ( mAttachment ) - { - mAttachment->OnDestroy(); - } - // Animators, Constraints etc. should be disconnected from the child's properties. PropertyOwner::Destroy(); } -void Node::Attach( NodeAttachment& object ) +void Node::CreateTransform( SceneGraph::TransformManager* transformManager ) { - DALI_ASSERT_DEBUG(!mAttachment); - - object.SetParent(*this); - - mAttachment = &object; - SetAllDirtyFlags(); - - mAttachment->ConnectedToSceneGraph(); + //Create a new transform + mTransformManager = transformManager; + mTransformId = 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 ); + + //Initialize all the input properties + mWorldPosition.Initialize( transformManager, mTransformId ); + mWorldScale.Initialize( transformManager, mTransformId ); + mWorldOrientation.Initialize( transformManager, mTransformId ); + mWorldMatrix.Initialize( transformManager, mTransformId ); + + //Set whether the position should use the anchor point + transformManager->SetPositionUsesAnchorPoint( mTransformId, mPositionUsesAnchorPoint ); } void Node::SetRoot(bool isRoot) @@ -122,7 +168,7 @@ void Node::SetRoot(bool isRoot) mIsRoot = isRoot; } -void Node::AddUniformMapping( UniformPropertyMapping* map ) +void Node::AddUniformMapping( OwnerPointer< UniformPropertyMapping >& map ) { PropertyOwner::AddUniformMapping( map ); mRegenerateUniformMap = 2; @@ -182,12 +228,6 @@ void Node::ConnectChild( Node* childNode ) // Inform property observers of new connection childNode->ConnectToSceneGraph(); - - // Inform child node attachment that the node has been added to the stage - if( childNode->mAttachment ) - { - childNode->mAttachment->ConnectedToSceneGraph(); - } } void Node::DisconnectChild( BufferIndex updateBufferIndex, Node& childNode ) @@ -214,6 +254,29 @@ void Node::DisconnectChild( BufferIndex updateBufferIndex, Node& childNode ) found->RecursiveDisconnectFromSceneGraph( updateBufferIndex ); } +void Node::AddRenderer( Renderer* renderer ) +{ + // Check that it has not been already added. + unsigned int rendererCount( mRenderer.Size() ); + for( unsigned int i(0); i < rendererCount; ++i ) + { + if( mRenderer[i] == renderer ) + { + // Renderer is already in the list. + return; + } + } + + // 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( rendererCount == 0 ) + { + mDirtyFlags |= TransformFlag; + } + + mRenderer.PushBack( renderer ); +} + void Node::RemoveRenderer( Renderer* renderer ) { unsigned int rendererCount( mRenderer.Size() ); @@ -231,21 +294,6 @@ int Node::GetDirtyFlags() const { // get initial dirty flags, they are reset ResetDefaultProperties, but setters may have made the node dirty already int flags = mDirtyFlags; - const bool sizeFlag = mSize.IsClean(); - - if ( !(flags & TransformFlag) ) - { - // Check whether the transform related properties have changed - if( !sizeFlag || - !mPosition.IsClean() || - !mOrientation.IsClean() || - !mScale.IsClean() || - mParentOrigin.InputChanged() || // parent origin and anchor point rarely change - mAnchorPoint.InputChanged() ) - { - flags |= TransformFlag; - } - } // Check whether the visible property has changed if ( !mVisible.IsClean() ) @@ -259,39 +307,26 @@ int Node::GetDirtyFlags() const flags |= ColorFlag; } - // Check whether the size property has changed - if ( !sizeFlag ) - { - flags |= SizeFlag; - } - return flags; } -void Node::ResetDefaultProperties( BufferIndex updateBufferIndex ) +void Node::ResetDirtyFlags( BufferIndex updateBufferIndex ) { - // clear dirty flags in parent origin & anchor point - mParentOrigin.Clear(); - mAnchorPoint.Clear(); - // Reset default properties - mSize.ResetToBaseValue( updateBufferIndex ); - mPosition.ResetToBaseValue( updateBufferIndex ); - mOrientation.ResetToBaseValue( updateBufferIndex ); - mScale.ResetToBaseValue( updateBufferIndex ); - mVisible.ResetToBaseValue( updateBufferIndex ); - mColor.ResetToBaseValue( updateBufferIndex ); - mDirtyFlags = NothingFlag; } -void Node::SetParent(Node& parentNode) +void Node::SetParent( Node& parentNode ) { DALI_ASSERT_ALWAYS(this != &parentNode); DALI_ASSERT_ALWAYS(!mIsRoot); DALI_ASSERT_ALWAYS(mParent == NULL); mParent = &parentNode; - mDepth = mParent->GetDepth() + 1u; + + if( mTransformId != INVALID_TRANSFORM_ID ) + { + mTransformManager->SetParent( mTransformId, parentNode.GetTransformId() ); + } } void Node::RecursiveDisconnectFromSceneGraph( BufferIndex updateBufferIndex ) @@ -310,21 +345,34 @@ void Node::RecursiveDisconnectFromSceneGraph( BufferIndex updateBufferIndex ) // Remove back-pointer to parent mParent = NULL; - mDepth = 0u; // Remove all child pointers mChildren.Clear(); - // Inform child node attachment that the node has been removed from the stage - if( mAttachment ) + if( mTransformId != INVALID_TRANSFORM_ID ) { - mAttachment->DisconnectedFromSceneGraph(); + mTransformManager->SetParent( mTransformId, INVALID_TRANSFORM_ID ); } - } } // namespace SceneGraph +template <> +void OwnerPointer::Reset() +{ + if( mObject != NULL ) + { + Dali::Internal::SceneGraph::Node::Delete( mObject ); + mObject = NULL; + } +} + } // namespace Internal +template <> +void OwnerContainer::Delete(Dali::Internal::SceneGraph::Node* pointer) +{ + Dali::Internal::SceneGraph::Node::Delete( pointer ); +} + } // namespace Dali