dali/internal/update/manager/update-manager.cpp

   1 /*
   2  * Copyright (c) 2020 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/manager/update-manager.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/integration-api/core.h>
  23
  24 #include <dali/internal/event/common/notification-manager.h>
  25 #include <dali/internal/event/common/property-notifier.h>
  26 #include <dali/internal/event/effects/shader-factory.h>
  27 #include <dali/internal/event/animation/animation-playlist.h>
  28
  29 #include <dali/internal/update/common/discard-queue.h>
  30 #include <dali/internal/update/controllers/render-message-dispatcher.h>
  31 #include <dali/internal/update/controllers/scene-controller-impl.h>
  32 #include <dali/internal/update/manager/frame-callback-processor.h>
  33 #include <dali/internal/update/manager/render-task-processor.h>
  34 #include <dali/internal/update/manager/update-algorithms.h>
  35 #include <dali/internal/update/manager/update-manager-debug.h>
  36 #include <dali/internal/update/manager/transform-manager.h>
  37 #include <dali/internal/update/nodes/node.h>
  38 #include <dali/internal/update/queue/update-message-queue.h>
  39
  40 #include <dali/internal/render/common/render-manager.h>
  41 #include <dali/internal/render/queue/render-queue.h>
  42
  43 // Un-comment to enable node tree debug logging
  44 //#define NODE_TREE_LOGGING 1
  45
  46 #if ( defined( DEBUG_ENABLED ) && defined( NODE_TREE_LOGGING ) )
  47 #define SNAPSHOT_NODE_LOGGING \
  48 const uint32_t FRAME_COUNT_TRIGGER = 16;\
  49 if( mImpl->frameCounter >= FRAME_COUNT_TRIGGER )\
  50   {\
  51     for( auto&& scene : mImpl->scenes )
  52     {\
  53       if ( scene && scene->root )\
  54       {\
  55         mImpl->frameCounter = 0;\
  56         PrintNodeTree( *scene->root, mSceneGraphBuffers.GetUpdateBufferIndex(), "" );\
  57       }\
  58     }\
  59   }\
  60 mImpl->frameCounter++;
  61 #else
  62 #define SNAPSHOT_NODE_LOGGING
  63 #endif
  64
  65 #if defined(DEBUG_ENABLED)
  66 extern Debug::Filter* gRenderTaskLogFilter;
  67 namespace
  68 {
  69 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_UPDATE_MANAGER" );
  70 } // unnamed namespace
  71 #endif
  72
  73
  74 using namespace Dali::Integration;
  75 using Dali::Internal::Update::MessageQueue;
  76
  77 namespace Dali
  78 {
  79
  80 namespace Internal
  81 {
  82
  83 namespace SceneGraph
  84 {
  85
  86 namespace
  87 {
  88 /**
  89  * Helper to Erase an object from OwnerContainer using discard queue
  90  * @param container to remove from
  91  * @param object to remove
  92  * @param discardQueue to put the object to
  93  * @param updateBufferIndex to use
  94  */
  95 template < class T >
  96 inline void EraseUsingDiscardQueue( OwnerContainer<T*>& container, T* object, DiscardQueue& discardQueue, BufferIndex updateBufferIndex )
  97 {
  98   DALI_ASSERT_DEBUG( object && "NULL object not allowed" );
  99
 100   // need to use the reference version of auto as we need the pointer to the pointer for the Release call below
 101   for( auto&& iter : container )
 102   {
 103     if ( iter == object )
 104     {
 105       // Transfer ownership to the discard queue, this keeps the object alive, until the render-thread has finished with it
 106       discardQueue.Add( updateBufferIndex, container.Release( &iter ) ); // take the address of the reference to a pointer (iter)
 107       return; // return as we only ever remove one object. Iterators to container are now invalidated as well so cannot continue
 108     }
 109   }
 110 }
 111
 112 /**
 113  * Descends into node's hierarchy and sorts the children of each child according to their depth-index.
 114  * @param[in] node The node whose hierarchy to descend
 115  */
 116 void SortSiblingNodesRecursively( Node& node )
 117 {
 118   NodeContainer& container = node.GetChildren();
 119   std::sort( container.Begin(), container.End(),
 120              []( Node* a, Node* b ) { return a->GetDepthIndex() < b->GetDepthIndex(); } );
 121
 122   // Descend tree and sort as well
 123   for( auto&& iter : container )
 124   {
 125     SortSiblingNodesRecursively( *iter );
 126   }
 127 }
 128
 129 } // unnamed namespace
 130
 131 /**
 132  * Structure to contain UpdateManager internal data
 133  */
 134 struct UpdateManager::Impl
 135 {
 136   // SceneInfo keeps the root node of the Scene, its scene graph render task list, and the list of Layer pointers sorted by depth
 137   struct SceneInfo
 138   {
 139     SceneInfo( Layer* root )                             ///< Constructor
 140     : root( root )
 141     {
 142     }
 143
 144     ~SceneInfo() = default;                                   ///< Default non-virtual destructor
 145     SceneInfo( SceneInfo&& rhs ) = default;                   ///< Move constructor
 146     SceneInfo& operator=( SceneInfo&& rhs ) = default;        ///< Move assignment operator
 147     SceneInfo& operator=( const SceneInfo& rhs ) = delete;    ///< Assignment operator
 148     SceneInfo( const SceneInfo& rhs ) = delete;               ///< Copy constructor
 149
 150     Layer* root{ nullptr };                                   ///< Root node (root is a layer). The layer is not stored in the node memory pool.
 151     OwnerPointer< RenderTaskList > taskList;                  ///< Scene graph render task list
 152     SortedLayerPointers sortedLayerList;                      ///< List of Layer pointers sorted by depth (one list of sorted layers per root)
 153     OwnerPointer< Scene > scene;                              ///< Scene graph object of the scene
 154   };
 155
 156   Impl( NotificationManager& notificationManager,
 157         CompleteNotificationInterface& animationPlaylist,
 158         PropertyNotifier& propertyNotifier,
 159         DiscardQueue& discardQueue,
 160         RenderController& renderController,
 161         RenderManager& renderManager,
 162         RenderQueue& renderQueue,
 163         SceneGraphBuffers& sceneGraphBuffers,
 164         RenderTaskProcessor& renderTaskProcessor )
 165   : renderMessageDispatcher( renderManager, renderQueue, sceneGraphBuffers ),
 166     notificationManager( notificationManager ),
 167     transformManager(),
 168     animationPlaylist( animationPlaylist ),
 169     propertyNotifier( propertyNotifier ),
 170     shaderSaver( NULL ),
 171     discardQueue( discardQueue ),
 172     renderController( renderController ),
 173     sceneController( NULL ),
 174     renderManager( renderManager ),
 175     renderQueue( renderQueue ),
 176     renderTaskProcessor( renderTaskProcessor ),
 177     backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
 178     renderers(),
 179     textureSets(),
 180     shaders(),
 181     panGestureProcessor( NULL ),
 182     messageQueue( renderController, sceneGraphBuffers ),
 183     frameCallbackProcessor( NULL ),
 184     keepRenderingSeconds( 0.0f ),
 185     nodeDirtyFlags( NodePropertyFlags::TRANSFORM ), // set to TransformFlag to ensure full update the first time through Update()
 186     frameCounter( 0 ),
 187     renderingBehavior( DevelStage::Rendering::IF_REQUIRED ),
 188     animationFinishedDuringUpdate( false ),
 189     previousUpdateScene( false ),
 190     renderTaskWaiting( false ),
 191     renderersAdded( false ),
 192     surfaceRectChanged( false )
 193   {
 194     sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue );
 195
 196     // create first 'dummy' node
 197     nodes.PushBack(0u);
 198   }
 199
 200   ~Impl()
 201   {
 202     // Disconnect render tasks from nodes, before destroying the nodes
 203     for( auto&& scene : scenes )
 204     {
 205       if ( scene && scene->taskList )
 206       {
 207         RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks();
 208         for ( auto&& task : tasks )
 209         {
 210           task->SetSourceNode( NULL );
 211         }
 212       }
 213     }
 214
 215     // UpdateManager owns the Nodes. Although Nodes are pool allocated they contain heap allocated parts
 216     // like custom properties, which get released here
 217     Vector<Node*>::Iterator iter = nodes.Begin()+1;
 218     Vector<Node*>::Iterator endIter = nodes.End();
 219     for(;iter!=endIter;++iter)
 220     {
 221       (*iter)->OnDestroy();
 222       Node::Delete(*iter);
 223     }
 224
 225     for( auto&& scene : scenes )
 226     {
 227       if ( scene && scene->root )
 228       {
 229         scene->root->OnDestroy();
 230         Node::Delete( scene->root );
 231       }
 232     }
 233     scenes.clear();
 234
 235     delete sceneController;
 236   }
 237
 238   /**
 239    * Lazy init for FrameCallbackProcessor.
 240    * @param[in]  updateManager  A reference to the update-manager
 241    */
 242   FrameCallbackProcessor& GetFrameCallbackProcessor( UpdateManager& updateManager )
 243   {
 244     if( ! frameCallbackProcessor )
 245     {
 246       frameCallbackProcessor = new FrameCallbackProcessor( updateManager, transformManager );
 247     }
 248     return *frameCallbackProcessor;
 249   }
 250
 251   SceneGraphBuffers                    sceneGraphBuffers;             ///< Used to keep track of which buffers are being written or read
 252   RenderMessageDispatcher              renderMessageDispatcher;       ///< Used for passing messages to the render-thread
 253   NotificationManager&                 notificationManager;           ///< Queues notification messages for the event-thread.
 254   TransformManager                     transformManager;              ///< Used to update the transformation matrices of the nodes
 255   CompleteNotificationInterface&       animationPlaylist;             ///< Holds handles to all the animations
 256   PropertyNotifier&                    propertyNotifier;              ///< Provides notification to applications when properties are modified.
 257   ShaderSaver*                         shaderSaver;                   ///< Saves shader binaries.
 258   DiscardQueue&                        discardQueue;                  ///< Nodes are added here when disconnected from the scene-graph.
 259   RenderController&                    renderController;              ///< render controller
 260   SceneControllerImpl*                 sceneController;               ///< scene controller
 261   RenderManager&                       renderManager;                 ///< This is responsible for rendering the results of each "update"
 262   RenderQueue&                         renderQueue;                   ///< Used to queue messages for the next render
 263   RenderTaskProcessor&                 renderTaskProcessor;           ///< Handles RenderTasks and RenderInstrucitons
 264
 265   Vector4                              backgroundColor;               ///< The glClear color used at the beginning of each frame.
 266
 267   using SceneInfoPtr = std::unique_ptr< SceneInfo >;
 268   std::vector< SceneInfoPtr >          scenes;                        ///< A container of SceneInfo.
 269
 270   Vector<Node*>                        nodes;                         ///< A container of all instantiated nodes
 271
 272   OwnerContainer< Camera* >            cameras;                       ///< A container of cameras
 273   OwnerContainer< PropertyOwner* >     customObjects;                 ///< A container of owned objects (with custom properties)
 274
 275   OwnerContainer< PropertyResetterBase* > propertyResetters;          ///< A container of property resetters
 276   OwnerContainer< Animation* >         animations;                    ///< A container of owned animations
 277   PropertyNotificationContainer        propertyNotifications;         ///< A container of owner property notifications.
 278   OwnerContainer< Renderer* >          renderers;                     ///< A container of owned renderers
 279   OwnerContainer< TextureSet* >        textureSets;                   ///< A container of owned texture sets
 280   OwnerContainer< Shader* >            shaders;                       ///< A container of owned shaders
 281   OwnerPointer< PanGesture >           panGestureProcessor;           ///< Owned pan gesture processor; it lives for the lifecycle of UpdateManager
 282
 283   MessageQueue                         messageQueue;                  ///< The messages queued from the event-thread
 284   std::vector<Internal::ShaderDataPtr> renderCompiledShaders;         ///< Shaders compiled on Render thread are inserted here for update thread to pass on to event thread.
 285   std::vector<Internal::ShaderDataPtr> updateCompiledShaders;         ///< Shaders to be sent from Update to Event
 286   Mutex                                compiledShaderMutex;           ///< lock to ensure no corruption on the renderCompiledShaders
 287
 288   OwnerPointer<FrameCallbackProcessor> frameCallbackProcessor;        ///< Owned FrameCallbackProcessor, only created if required.
 289
 290   float                                keepRenderingSeconds;          ///< Set via Dali::Stage::KeepRendering
 291   NodePropertyFlags                    nodeDirtyFlags;                ///< cumulative node dirty flags from previous frame
 292   uint32_t                             frameCounter;                  ///< Frame counter used in debugging to choose which frame to debug and which to ignore.
 293
 294   DevelStage::Rendering                renderingBehavior;             ///< Set via DevelStage::SetRenderingBehavior
 295
 296   bool                                 animationFinishedDuringUpdate; ///< Flag whether any animations finished during the Update()
 297   bool                                 previousUpdateScene;           ///< True if the scene was updated in the previous frame (otherwise it was optimized out)
 298   bool                                 renderTaskWaiting;             ///< A REFRESH_ONCE render task is waiting to be rendered
 299   bool                                 renderersAdded;                ///< Flag to keep track when renderers have been added to avoid unnecessary processing
 300   bool                                 surfaceRectChanged;            ///< True if the default surface rect is changed
 301
 302 private:
 303
 304   Impl( const Impl& ); ///< Undefined
 305   Impl& operator=( const Impl& ); ///< Undefined
 306 };
 307
 308 UpdateManager::UpdateManager( NotificationManager& notificationManager,
 309                               CompleteNotificationInterface& animationFinishedNotifier,
 310                               PropertyNotifier& propertyNotifier,
 311                               DiscardQueue& discardQueue,
 312                               RenderController& controller,
 313                               RenderManager& renderManager,
 314                               RenderQueue& renderQueue,
 315                               RenderTaskProcessor& renderTaskProcessor )
 316   : mImpl(NULL)
 317 {
 318   mImpl = new Impl( notificationManager,
 319                     animationFinishedNotifier,
 320                     propertyNotifier,
 321                     discardQueue,
 322                     controller,
 323                     renderManager,
 324                     renderQueue,
 325                     mSceneGraphBuffers,
 326                     renderTaskProcessor );
 327
 328 }
 329
 330 UpdateManager::~UpdateManager()
 331 {
 332   delete mImpl;
 333 }
 334
 335 void UpdateManager::InstallRoot( OwnerPointer<Layer>& layer )
 336 {
 337   DALI_ASSERT_DEBUG( layer->IsLayer() );
 338   DALI_ASSERT_DEBUG( layer->GetParent() == NULL);
 339
 340   Layer* rootLayer = layer.Release();
 341
 342   DALI_ASSERT_DEBUG( std::find_if( mImpl->scenes.begin(), mImpl->scenes.end(),
 343                                    [rootLayer]( Impl::SceneInfoPtr& scene )
 344                                    {
 345                                      return scene && scene->root == rootLayer;
 346                                    }
 347                                  ) == mImpl->scenes.end() && "Root Node already installed" );
 348
 349   rootLayer->CreateTransform( &mImpl->transformManager );
 350   rootLayer->SetRoot(true);
 351
 352   mImpl->scenes.emplace_back( new Impl::SceneInfo( rootLayer ) );
 353 }
 354
 355 void UpdateManager::UninstallRoot( Layer* layer )
 356 {
 357   DALI_ASSERT_DEBUG( layer->IsLayer() );
 358   DALI_ASSERT_DEBUG( layer->GetParent() == NULL );
 359
 360   for (auto iter = mImpl->scenes.begin(); iter != mImpl->scenes.end(); ++iter)
 361   {
 362     if( (*iter) && (*iter)->root == layer )
 363     {
 364       mImpl->scenes.erase( iter );
 365       break;
 366     }
 367   }
 368
 369   mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), layer );
 370
 371   // Notify the layer about impending destruction
 372   layer->OnDestroy();
 373 }
 374
 375 void UpdateManager::AddNode( OwnerPointer<Node>& node )
 376 {
 377   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
 378
 379   // Nodes must be sorted by pointer
 380   Node* rawNode = node.Release();
 381   DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] AddNode\n", rawNode );
 382
 383   Vector<Node*>::Iterator begin = mImpl->nodes.Begin();
 384   for( Vector<Node*>::Iterator iter = mImpl->nodes.End()-1; iter >= begin; --iter )
 385   {
 386     if( rawNode > (*iter) )
 387     {
 388       mImpl->nodes.Insert((iter+1), rawNode );
 389       rawNode->CreateTransform( &mImpl->transformManager );
 390       return;
 391     }
 392   }
 393 }
 394
 395 void UpdateManager::ConnectNode( Node* parent, Node* node )
 396 {
 397   DALI_ASSERT_ALWAYS( NULL != parent );
 398   DALI_ASSERT_ALWAYS( NULL != node );
 399   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
 400
 401   DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] ConnectNode\n", node );
 402
 403   parent->ConnectChild( node );
 404
 405   // Inform the frame-callback-processor, if set, about the node-hierarchy changing
 406   if( mImpl->frameCallbackProcessor )
 407   {
 408     mImpl->frameCallbackProcessor->NodeHierarchyChanged();
 409   }
 410 }
 411
 412 void UpdateManager::DisconnectNode( Node* node )
 413 {
 414   DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] DisconnectNode\n", node );
 415
 416   Node* parent = node->GetParent();
 417   DALI_ASSERT_ALWAYS( NULL != parent );
 418   parent->SetDirtyFlag( NodePropertyFlags::CHILD_DELETED ); // make parent dirty so that render items dont get reused
 419
 420   parent->DisconnectChild( mSceneGraphBuffers.GetUpdateBufferIndex(), *node );
 421
 422   // Inform the frame-callback-processor, if set, about the node-hierarchy changing
 423   if( mImpl->frameCallbackProcessor )
 424   {
 425     mImpl->frameCallbackProcessor->NodeHierarchyChanged();
 426   }
 427 }
 428
 429 void UpdateManager::DestroyNode( Node* node )
 430 {
 431   DALI_ASSERT_ALWAYS( NULL != node );
 432   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should have been disconnected
 433
 434   DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] DestroyNode\n", node );
 435
 436   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
 437   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
 438   for(;iter!=endIter;++iter)
 439   {
 440     if((*iter) == node)
 441     {
 442       mImpl->nodes.Erase(iter);
 443       break;
 444     }
 445   }
 446
 447   mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), node );
 448
 449   // Notify the Node about impending destruction
 450   node->OnDestroy();
 451 }
 452
 453 void UpdateManager::AddCamera( OwnerPointer< Camera >& camera )
 454 {
 455   mImpl->cameras.PushBack( camera.Release() ); // takes ownership
 456 }
 457
 458 void UpdateManager::RemoveCamera( Camera* camera )
 459 {
 460   // Find the camera and destroy it
 461   EraseUsingDiscardQueue( mImpl->cameras, camera, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
 462 }
 463
 464 void UpdateManager::AddObject( OwnerPointer<PropertyOwner>& object )
 465 {
 466   mImpl->customObjects.PushBack( object.Release() );
 467 }
 468
 469 void UpdateManager::RemoveObject( PropertyOwner* object )
 470 {
 471   mImpl->customObjects.EraseObject( object );
 472 }
 473
 474 void UpdateManager::AddRenderTaskList( OwnerPointer<RenderTaskList>& taskList )
 475 {
 476   RenderTaskList* taskListPointer = taskList.Release();
 477   taskListPointer->SetRenderMessageDispatcher( &mImpl->renderMessageDispatcher );
 478
 479   mImpl->scenes.back()->taskList = taskListPointer;
 480 }
 481
 482 void UpdateManager::RemoveRenderTaskList( RenderTaskList* taskList )
 483 {
 484   for ( auto&& scene : mImpl->scenes )
 485   {
 486     if ( scene && scene->taskList == taskList )
 487     {
 488       scene->taskList.Reset();
 489       break;
 490     }
 491   }
 492 }
 493
 494 void UpdateManager::AddScene( OwnerPointer< Scene >& scene )
 495 {
 496   mImpl->scenes.back()->scene = scene.Release();
 497
 498   // Initialize the context from render manager
 499   typedef MessageValue1< RenderManager, SceneGraph::Scene* > DerivedType;
 500
 501   // Reserve some memory inside the render queue
 502   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 503
 504   // Construct message in the render queue memory; note that delete should not be called on the return value
 505   SceneGraph::Scene& sceneObject = *mImpl->scenes.back()->scene;
 506   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::InitializeScene, &sceneObject );
 507 }
 508
 509 void UpdateManager::RemoveScene( Scene* scene )
 510 {
 511   // Initialize the context from render manager
 512   typedef MessageValue1< RenderManager, SceneGraph::Scene* > DerivedType;
 513
 514   // Reserve some memory inside the render queue
 515   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 516
 517   // Construct message in the render queue memory; note that delete should not be called on the return value
 518   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::UninitializeScene, scene );
 519
 520   for ( auto&& sceneInfo : mImpl->scenes )
 521   {
 522     if ( sceneInfo && sceneInfo->scene && sceneInfo->scene.Get() == scene )
 523     {
 524       mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), sceneInfo->scene.Release() ); // take the address of the reference to a pointer
 525       break;
 526     }
 527   }
 528 }
 529
 530 void UpdateManager::AddAnimation( OwnerPointer< SceneGraph::Animation >& animation )
 531 {
 532   mImpl->animations.PushBack( animation.Release() );
 533 }
 534
 535 void UpdateManager::StopAnimation( Animation* animation )
 536 {
 537   DALI_ASSERT_DEBUG( animation && "NULL animation called to stop" );
 538
 539   bool animationFinished = animation->Stop( mSceneGraphBuffers.GetUpdateBufferIndex() );
 540
 541   mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || animationFinished;
 542 }
 543
 544 void UpdateManager::RemoveAnimation( Animation* animation )
 545 {
 546   DALI_ASSERT_DEBUG( animation && "NULL animation called to remove" );
 547
 548   animation->OnDestroy( mSceneGraphBuffers.GetUpdateBufferIndex() );
 549
 550   DALI_ASSERT_DEBUG( animation->GetState() == Animation::Destroyed );
 551 }
 552
 553 bool UpdateManager::IsAnimationRunning() const
 554 {
 555   // Find any animation that isn't stopped or paused
 556   for ( auto&& iter : mImpl->animations )
 557   {
 558     const Animation::State state = iter->GetState();
 559
 560     if (state != Animation::Stopped &&
 561         state != Animation::Paused)
 562     {
 563       return true; // stop iteration as soon as first one is found
 564     }
 565   }
 566
 567   return false;
 568 }
 569
 570 void UpdateManager::AddPropertyResetter( OwnerPointer<PropertyResetterBase>& propertyResetter )
 571 {
 572   propertyResetter->Initialize();
 573   mImpl->propertyResetters.PushBack( propertyResetter.Release() );
 574 }
 575
 576 void UpdateManager::AddPropertyNotification( OwnerPointer< PropertyNotification >& propertyNotification )
 577 {
 578   mImpl->propertyNotifications.PushBack( propertyNotification.Release() );
 579 }
 580
 581 void UpdateManager::RemovePropertyNotification( PropertyNotification* propertyNotification )
 582 {
 583   mImpl->propertyNotifications.EraseObject( propertyNotification );
 584 }
 585
 586 void UpdateManager::PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode )
 587 {
 588   DALI_ASSERT_DEBUG( propertyNotification && "propertyNotification scene graph object missing" );
 589   propertyNotification->SetNotifyMode( notifyMode );
 590 }
 591
 592 void UpdateManager::AddShader( OwnerPointer< Shader >& shader )
 593 {
 594   mImpl->shaders.PushBack( shader.Release() );
 595 }
 596
 597 void UpdateManager::RemoveShader( Shader* shader )
 598 {
 599   // Find the shader and destroy it
 600   EraseUsingDiscardQueue( mImpl->shaders, shader, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
 601 }
 602
 603 void UpdateManager::SetShaderProgram( Shader* shader,
 604                                       Internal::ShaderDataPtr shaderData, bool modifiesGeometry )
 605 {
 606   if( shaderData )
 607   {
 608
 609     typedef MessageValue3< Shader, Internal::ShaderDataPtr, ProgramCache*, bool> DerivedType;
 610
 611     // Reserve some memory inside the render queue
 612     uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 613
 614     // Construct message in the render queue memory; note that delete should not be called on the return value
 615     new (slot) DerivedType( shader, &Shader::SetProgram, shaderData, mImpl->renderManager.GetProgramCache(), modifiesGeometry );
 616   }
 617 }
 618
 619 void UpdateManager::SaveBinary( Internal::ShaderDataPtr shaderData )
 620 {
 621   DALI_ASSERT_DEBUG( shaderData && "No NULL shader data pointers please." );
 622   DALI_ASSERT_DEBUG( shaderData->GetBufferSize() > 0 && "Shader binary empty so nothing to save." );
 623   {
 624     // lock as update might be sending previously compiled shaders to event thread
 625     Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
 626     mImpl->renderCompiledShaders.push_back( shaderData );
 627   }
 628 }
 629
 630 void UpdateManager::SetShaderSaver( ShaderSaver& upstream )
 631 {
 632   mImpl->shaderSaver = &upstream;
 633 }
 634
 635 void UpdateManager::AddRenderer( OwnerPointer< Renderer >& renderer )
 636 {
 637   DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] AddRenderer\n", renderer.Get() );
 638
 639   renderer->ConnectToSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() );
 640   mImpl->renderers.PushBack( renderer.Release() );
 641   mImpl->renderersAdded = true;
 642 }
 643
 644 void UpdateManager::RemoveRenderer( Renderer* renderer )
 645 {
 646   DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] RemoveRenderer\n", renderer );
 647
 648   // Find the renderer and destroy it
 649   EraseUsingDiscardQueue( mImpl->renderers, renderer, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
 650   // Need to remove the render object as well
 651   renderer->DisconnectFromSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() );
 652 }
 653
 654 void UpdateManager::SetPanGestureProcessor( PanGesture* panGestureProcessor )
 655 {
 656   DALI_ASSERT_DEBUG( NULL != panGestureProcessor );
 657
 658   mImpl->panGestureProcessor = panGestureProcessor;
 659 }
 660
 661 void UpdateManager::AddTextureSet( OwnerPointer< TextureSet >& textureSet )
 662 {
 663   mImpl->textureSets.PushBack( textureSet.Release() );
 664 }
 665
 666 void UpdateManager::RemoveTextureSet( TextureSet* textureSet )
 667 {
 668   mImpl->textureSets.EraseObject( textureSet );
 669 }
 670
 671 uint32_t* UpdateManager::ReserveMessageSlot( uint32_t size, bool updateScene )
 672 {
 673   return mImpl->messageQueue.ReserveMessageSlot( size, updateScene );
 674 }
 675
 676 void UpdateManager::EventProcessingStarted()
 677 {
 678   mImpl->messageQueue.EventProcessingStarted();
 679 }
 680
 681 bool UpdateManager::FlushQueue()
 682 {
 683   return mImpl->messageQueue.FlushQueue();
 684 }
 685
 686 void UpdateManager::ResetProperties( BufferIndex bufferIndex )
 687 {
 688   // Clear the "animations finished" flag; This should be set if any (previously playing) animation is stopped
 689   mImpl->animationFinishedDuringUpdate = false;
 690
 691   // Reset all animating / constrained properties
 692   std::vector<PropertyResetterBase*>toDelete;
 693   for( auto&& element : mImpl->propertyResetters )
 694   {
 695     element->ResetToBaseValue( bufferIndex );
 696     if( element->IsFinished() )
 697     {
 698       toDelete.push_back( element );
 699     }
 700   }
 701
 702   // If a resetter is no longer required (the animator or constraint has been removed), delete it.
 703   for( auto&& elementPtr : toDelete )
 704   {
 705     mImpl->propertyResetters.EraseObject( elementPtr );
 706   }
 707
 708   // Clear all root nodes dirty flags
 709   for( auto& scene : mImpl->scenes )
 710   {
 711     auto root = scene->root;
 712     root->ResetDirtyFlags( bufferIndex );
 713   }
 714
 715   // Clear node dirty flags
 716   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
 717   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
 718   for( ;iter != endIter; ++iter )
 719   {
 720     (*iter)->ResetDirtyFlags( bufferIndex );
 721   }
 722 }
 723
 724 bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, uint32_t lastVSyncTimeMilliseconds, uint32_t nextVSyncTimeMilliseconds )
 725 {
 726   bool gestureUpdated( false );
 727
 728   if( mImpl->panGestureProcessor )
 729   {
 730     // gesture processor only supports default properties
 731     mImpl->panGestureProcessor->ResetDefaultProperties( bufferIndex ); // Needs to be done every time as gesture data is written directly to an update-buffer rather than via a message
 732     gestureUpdated |= mImpl->panGestureProcessor->UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 733   }
 734
 735   return gestureUpdated;
 736 }
 737
 738 void UpdateManager::Animate( BufferIndex bufferIndex, float elapsedSeconds )
 739 {
 740   auto&& iter = mImpl->animations.Begin();
 741   bool animationLooped = false;
 742
 743   while ( iter != mImpl->animations.End() )
 744   {
 745     Animation* animation = *iter;
 746     bool finished = false;
 747     bool looped = false;
 748     bool progressMarkerReached = false;
 749     animation->Update( bufferIndex, elapsedSeconds, looped, finished, progressMarkerReached );
 750
 751     if ( progressMarkerReached )
 752     {
 753       mImpl->notificationManager.QueueMessage( Internal::NotifyProgressReachedMessage( mImpl->animationPlaylist, animation ) );
 754     }
 755
 756     mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || finished;
 757     animationLooped = animationLooped || looped;
 758
 759     // Remove animations that had been destroyed but were still waiting for an update
 760     if (animation->GetState() == Animation::Destroyed)
 761     {
 762       iter = mImpl->animations.Erase(iter);
 763     }
 764     else
 765     {
 766       ++iter;
 767     }
 768   }
 769
 770   // queue the notification on finished or looped (to update loop count)
 771   if ( mImpl->animationFinishedDuringUpdate || animationLooped )
 772   {
 773     // The application should be notified by NotificationManager, in another thread
 774     mImpl->notificationManager.QueueCompleteNotification( &mImpl->animationPlaylist );
 775   }
 776 }
 777
 778 void UpdateManager::ConstrainCustomObjects( BufferIndex bufferIndex )
 779 {
 780   //Constrain custom objects (in construction order)
 781   for ( auto&& object : mImpl->customObjects )
 782   {
 783     ConstrainPropertyOwner( *object, bufferIndex );
 784   }
 785 }
 786
 787 void UpdateManager::ConstrainRenderTasks( BufferIndex bufferIndex )
 788 {
 789   // Constrain render-tasks
 790   for ( auto&& scene : mImpl->scenes )
 791   {
 792     if ( scene && scene->taskList )
 793     {
 794       RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks();
 795       for ( auto&& task : tasks )
 796       {
 797         ConstrainPropertyOwner( *task, bufferIndex );
 798       }
 799     }
 800   }
 801 }
 802
 803 void UpdateManager::ConstrainShaders( BufferIndex bufferIndex )
 804 {
 805   // constrain shaders... (in construction order)
 806   for ( auto&& shader : mImpl->shaders )
 807   {
 808     ConstrainPropertyOwner( *shader, bufferIndex );
 809   }
 810 }
 811
 812 void UpdateManager::ProcessPropertyNotifications( BufferIndex bufferIndex )
 813 {
 814   for( auto&& notification : mImpl->propertyNotifications )
 815   {
 816     bool valid = notification->Check( bufferIndex );
 817     if(valid)
 818     {
 819       mImpl->notificationManager.QueueMessage( PropertyChangedMessage( mImpl->propertyNotifier, notification, notification->GetValidity() ) );
 820     }
 821   }
 822 }
 823
 824 void UpdateManager::ForwardCompiledShadersToEventThread()
 825 {
 826   DALI_ASSERT_DEBUG( (mImpl->shaderSaver != 0) && "shaderSaver should be wired-up during startup." );
 827   if( mImpl->shaderSaver )
 828   {
 829     // lock and swap the queues
 830     {
 831       // render might be attempting to send us more binaries at the same time
 832       Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
 833       mImpl->renderCompiledShaders.swap( mImpl->updateCompiledShaders );
 834     }
 835
 836     if( mImpl->updateCompiledShaders.size() > 0 )
 837     {
 838       ShaderSaver& factory = *mImpl->shaderSaver;
 839       for( auto&& shader : mImpl->updateCompiledShaders )
 840       {
 841         mImpl->notificationManager.QueueMessage( ShaderCompiledMessage( factory, shader ) );
 842       }
 843       // we don't need them in update anymore
 844       mImpl->updateCompiledShaders.clear();
 845     }
 846   }
 847 }
 848
 849 void UpdateManager::UpdateRenderers( BufferIndex bufferIndex )
 850 {
 851   for( auto&& renderer : mImpl->renderers )
 852   {
 853     //Apply constraints
 854     ConstrainPropertyOwner( *renderer, bufferIndex );
 855
 856     renderer->PrepareRender( bufferIndex );
 857   }
 858 }
 859
 860 void UpdateManager::UpdateNodes( BufferIndex bufferIndex )
 861 {
 862   mImpl->nodeDirtyFlags = NodePropertyFlags::NOTHING;
 863
 864   for ( auto&& scene : mImpl->scenes )
 865   {
 866     if ( scene && scene->root )
 867     {
 868       // Prepare resources, update shaders, for each node
 869       // And add the renderers to the sorted layers. Start from root, which is also a layer
 870       mImpl->nodeDirtyFlags |= UpdateNodeTree( *scene->root,
 871                                               bufferIndex,
 872                                               mImpl->renderQueue );
 873     }
 874   }
 875 }
 876
 877 uint32_t UpdateManager::Update( float elapsedSeconds,
 878                                 uint32_t lastVSyncTimeMilliseconds,
 879                                 uint32_t nextVSyncTimeMilliseconds,
 880                                 bool renderToFboEnabled,
 881                                 bool isRenderingToFbo )
 882 {
 883   const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
 884
 885   //Clear nodes/resources which were previously discarded
 886   mImpl->discardQueue.Clear( bufferIndex );
 887
 888   //Process Touches & Gestures
 889   const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 890
 891   bool updateScene = // The scene-graph requires an update if..
 892       (mImpl->nodeDirtyFlags & RenderableUpdateFlags) ||    // ..nodes were dirty in previous frame OR
 893       IsAnimationRunning()                            ||    // ..at least one animation is running OR
 894       mImpl->messageQueue.IsSceneUpdateRequired()     ||    // ..a message that modifies the scene graph node tree is queued OR
 895       gestureUpdated;                                       // ..a gesture property was updated
 896
 897   bool keepRendererRendering = false;
 898
 899   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 900   // values if the scene was updated in the previous frame.
 901   if( updateScene || mImpl->previousUpdateScene )
 902   {
 903     //Reset properties from the previous update
 904     ResetProperties( bufferIndex );
 905     mImpl->transformManager.ResetToBaseValue();
 906   }
 907
 908   // Process the queued scene messages. Note, MessageQueue::FlushQueue may be called
 909   // between calling IsSceneUpdateRequired() above and here, so updateScene should
 910   // be set again
 911   updateScene |= mImpl->messageQueue.ProcessMessages( bufferIndex );
 912
 913   //Forward compiled shader programs to event thread for saving
 914   ForwardCompiledShadersToEventThread();
 915
 916   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 917   // renderer lists if the scene was updated in the previous frame.
 918   // We should not start skipping update steps or reusing lists until there has been two frames where nothing changes
 919   if( updateScene || mImpl->previousUpdateScene )
 920   {
 921     //Animate
 922     Animate( bufferIndex, elapsedSeconds );
 923
 924     //Constraint custom objects
 925     ConstrainCustomObjects( bufferIndex );
 926
 927     //Clear the lists of renderers from the previous update
 928     for( auto&& scene : mImpl->scenes )
 929     {
 930       if ( scene )
 931       {
 932         for( auto&& layer : scene->sortedLayerList )
 933         {
 934           if ( layer )
 935           {
 936             layer->ClearRenderables();
 937           }
 938         }
 939       }
 940     }
 941
 942     // Call the frame-callback-processor if set
 943     if( mImpl->frameCallbackProcessor )
 944     {
 945       mImpl->frameCallbackProcessor->Update( bufferIndex, elapsedSeconds );
 946     }
 947
 948     //Update node hierarchy, apply constraints and perform sorting / culling.
 949     //This will populate each Layer with a list of renderers which are ready.
 950     UpdateNodes( bufferIndex );
 951
 952     //Apply constraints to RenderTasks, shaders
 953     ConstrainRenderTasks( bufferIndex );
 954     ConstrainShaders( bufferIndex );
 955
 956     //Update renderers and apply constraints
 957     UpdateRenderers( bufferIndex );
 958
 959     //Update the transformations of all the nodes
 960     mImpl->transformManager.Update();
 961
 962     //Process Property Notifications
 963     ProcessPropertyNotifications( bufferIndex );
 964
 965     //Update cameras
 966     for( auto&& cameraIterator : mImpl->cameras )
 967     {
 968       cameraIterator->Update( bufferIndex );
 969     }
 970
 971     //Process the RenderTasks if renderers exist. This creates the instructions for rendering the next frame.
 972     //reset the update buffer index and make sure there is enough room in the instruction container
 973     if( mImpl->renderersAdded )
 974     {
 975       // Calculate how many render tasks we have in total
 976       std::size_t numberOfRenderTasks = 0;
 977       for (auto&& scene : mImpl->scenes )
 978       {
 979         if ( scene && scene->taskList )
 980         {
 981           numberOfRenderTasks += scene->taskList->GetTasks().Count();
 982         }
 983       }
 984
 985
 986       std::size_t numberOfRenderInstructions = 0;
 987       for ( auto&& scene : mImpl->scenes )
 988       {
 989         if ( scene && scene->root && scene->taskList && scene->scene )
 990         {
 991           scene->scene->GetRenderInstructions().ResetAndReserve( bufferIndex,
 992                                                      static_cast<uint32_t>( scene->taskList->GetTasks().Count() ) );
 993
 994           keepRendererRendering |= mImpl->renderTaskProcessor.Process( bufferIndex,
 995                                               *scene->taskList,
 996                                               *scene->root,
 997                                               scene->sortedLayerList,
 998                                               scene->scene->GetRenderInstructions(),
 999                                               renderToFboEnabled,
1000                                               isRenderingToFbo );
1001
1002           numberOfRenderInstructions += scene->scene->GetRenderInstructions().Count( bufferIndex );
1003         }
1004       }
1005
1006       DALI_LOG_INFO( gLogFilter, Debug::General,
1007                      "Update: numberOfRenderTasks(%d), Render Instructions(%d)\n",
1008                      numberOfRenderTasks, numberOfRenderInstructions );
1009     }
1010   }
1011
1012   for ( auto&& scene : mImpl->scenes )
1013   {
1014     if ( scene && scene->root && scene->taskList )
1015     {
1016       RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks();
1017
1018       // check the countdown and notify
1019       bool doRenderOnceNotify = false;
1020       mImpl->renderTaskWaiting = false;
1021       for ( auto&& renderTask : tasks )
1022       {
1023         renderTask->UpdateState();
1024
1025         if( renderTask->IsWaitingToRender() &&
1026             renderTask->ReadyToRender( bufferIndex ) /*avoid updating forever when source actor is off-stage*/ )
1027         {
1028           mImpl->renderTaskWaiting = true; // keep update/render threads alive
1029         }
1030
1031         if( renderTask->HasRendered() )
1032         {
1033           doRenderOnceNotify = true;
1034         }
1035       }
1036
1037       if( doRenderOnceNotify )
1038       {
1039         DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n");
1040         mImpl->notificationManager.QueueCompleteNotification( scene->taskList->GetCompleteNotificationInterface() );
1041       }
1042     }
1043   }
1044
1045   // Macro is undefined in release build.
1046   SNAPSHOT_NODE_LOGGING;
1047
1048   // A ResetProperties() may be required in the next frame
1049   mImpl->previousUpdateScene = updateScene;
1050
1051   // Check whether further updates are required
1052   uint32_t keepUpdating = KeepUpdatingCheck( elapsedSeconds );
1053
1054   if( keepRendererRendering )
1055   {
1056     keepUpdating |= KeepUpdating::STAGE_KEEP_RENDERING;
1057
1058     // Set dirty flags for next frame to continue rendering
1059     mImpl->nodeDirtyFlags |= RenderableUpdateFlags;
1060   }
1061
1062   // tell the update manager that we're done so the queue can be given to event thread
1063   mImpl->notificationManager.UpdateCompleted();
1064
1065   // The update has finished; swap the double-buffering indices
1066   mSceneGraphBuffers.Swap();
1067
1068   return keepUpdating;
1069 }
1070
1071 uint32_t UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const
1072 {
1073   // Update the duration set via Stage::KeepRendering()
1074   if ( mImpl->keepRenderingSeconds > 0.0f )
1075   {
1076     mImpl->keepRenderingSeconds -= elapsedSeconds;
1077   }
1078
1079   uint32_t keepUpdatingRequest = KeepUpdating::NOT_REQUESTED;
1080
1081   // If the rendering behavior is set to continuously render, then continue to render.
1082   // If Stage::KeepRendering() has been called, then continue until the duration has elapsed.
1083   // Keep updating until no messages are received and no animations are running.
1084   // If an animation has just finished, update at least once more for Discard end-actions.
1085   // No need to check for renderQueue as there is always a render after update and if that
1086   // render needs another update it will tell the adaptor to call update again
1087
1088   if ( ( mImpl->renderingBehavior == DevelStage::Rendering::CONTINUOUSLY ) ||
1089        ( mImpl->keepRenderingSeconds > 0.0f ) )
1090   {
1091     keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING;
1092   }
1093
1094   if ( IsAnimationRunning() ||
1095        mImpl->animationFinishedDuringUpdate )
1096   {
1097     keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING;
1098   }
1099
1100   if ( mImpl->renderTaskWaiting )
1101   {
1102     keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC;
1103   }
1104
1105   return keepUpdatingRequest;
1106 }
1107
1108 void UpdateManager::SetDefaultSurfaceRect( const Rect<int32_t>& rect )
1109 {
1110   mImpl->surfaceRectChanged = true;
1111
1112   typedef MessageValue1< RenderManager, Rect<int32_t> > DerivedType;
1113
1114   // Reserve some memory inside the render queue
1115   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1116
1117   // Construct message in the render queue memory; note that delete should not be called on the return value
1118   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceRect, rect );
1119 }
1120
1121 void UpdateManager::SurfaceReplaced( Scene* scene )
1122 {
1123   typedef MessageValue1< RenderManager, Scene* > DerivedType;
1124
1125   // Reserve some memory inside the render queue
1126   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1127
1128   // Construct message in the render queue memory; note that delete should not be called on the return value
1129   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SurfaceReplaced, scene );
1130 }
1131
1132 void UpdateManager::SetDefaultSurfaceOrientation( int orientation )
1133 {
1134   typedef MessageValue1< RenderManager, int > DerivedType;
1135
1136   // Reserve some memory inside the render queue
1137   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1138
1139   // Construct message in the render queue memory; note that delete should not be called on the return value
1140   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceOrientation, orientation );
1141 }
1142
1143 void UpdateManager::KeepRendering( float durationSeconds )
1144 {
1145   mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds );
1146 }
1147
1148 void UpdateManager::SetRenderingBehavior( DevelStage::Rendering renderingBehavior )
1149 {
1150   mImpl->renderingBehavior = renderingBehavior;
1151 }
1152
1153 void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, const Layer* rootLayer )
1154 {
1155   for ( auto&& scene : mImpl->scenes )
1156   {
1157     if ( scene && scene->root == rootLayer )
1158     {
1159       scene->sortedLayerList = layers;
1160       break;
1161     }
1162   }
1163 }
1164
1165 void UpdateManager::SetDepthIndices( OwnerPointer< NodeDepths >& nodeDepths )
1166 {
1167   // note,this vector is already in depth order. It could be used as-is to
1168   // remove sorting in update algorithm. However, it lacks layer boundary markers.
1169   for( auto&& iter : nodeDepths->nodeDepths )
1170   {
1171     iter.node->SetDepthIndex( iter.sortedDepth );
1172   }
1173
1174   for ( auto&& scene : mImpl->scenes )
1175   {
1176     if ( scene )
1177     {
1178       // Go through node hierarchy and rearrange siblings according to depth-index
1179       SortSiblingNodesRecursively( *scene->root );
1180     }
1181   }
1182 }
1183
1184 bool UpdateManager::IsDefaultSurfaceRectChanged()
1185 {
1186   bool surfaceRectChanged = mImpl->surfaceRectChanged;
1187
1188   // Reset the flag
1189   mImpl->surfaceRectChanged = false;
1190
1191   return surfaceRectChanged;
1192 }
1193
1194 void UpdateManager::AddFrameCallback( OwnerPointer< FrameCallback >& frameCallback, const Node* rootNode )
1195 {
1196   mImpl->GetFrameCallbackProcessor( *this ).AddFrameCallback( frameCallback, rootNode );
1197 }
1198
1199 void UpdateManager::RemoveFrameCallback( FrameCallbackInterface* frameCallback )
1200 {
1201   mImpl->GetFrameCallbackProcessor( *this ).RemoveFrameCallback( frameCallback );
1202 }
1203
1204 void UpdateManager::AddSampler( OwnerPointer< Render::Sampler >& sampler )
1205 {
1206   // Message has ownership of Sampler while in transit from update to render
1207   typedef MessageValue1< RenderManager, OwnerPointer< Render::Sampler > > DerivedType;
1208
1209   // Reserve some memory inside the render queue
1210   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1211
1212   // Construct message in the render queue memory; note that delete should not be called on the return value
1213   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddSampler, sampler );
1214 }
1215
1216 void UpdateManager::RemoveSampler( Render::Sampler* sampler )
1217 {
1218   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1219
1220   // Reserve some memory inside the render queue
1221   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1222
1223   // Construct message in the render queue memory; note that delete should not be called on the return value
1224   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveSampler, sampler );
1225 }
1226
1227 void UpdateManager::SetFilterMode( Render::Sampler* sampler, uint32_t minFilterMode, uint32_t magFilterMode )
1228 {
1229   typedef MessageValue3< RenderManager, Render::Sampler*, uint32_t, uint32_t > DerivedType;
1230
1231   // Reserve some memory inside the render queue
1232   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1233
1234   // Construct message in the render queue memory; note that delete should not be called on the return value
1235   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
1236 }
1237
1238 void UpdateManager::SetWrapMode( Render::Sampler* sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode )
1239 {
1240   typedef MessageValue4< RenderManager, Render::Sampler*, uint32_t, uint32_t, uint32_t > DerivedType;
1241
1242   // Reserve some memory inside the render queue
1243   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1244
1245   // Construct message in the render queue memory; note that delete should not be called on the return value
1246   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode );
1247 }
1248
1249 void UpdateManager::AddPropertyBuffer( OwnerPointer< Render::PropertyBuffer >& propertyBuffer )
1250 {
1251   // Message has ownership of format while in transit from update -> render
1252   typedef MessageValue1< RenderManager, OwnerPointer< Render::PropertyBuffer > > DerivedType;
1253
1254   // Reserve some memory inside the render queue
1255   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1256
1257   // Construct message in the render queue memory; note that delete should not be called on the return value
1258   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddPropertyBuffer, propertyBuffer );
1259 }
1260
1261 void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1262 {
1263   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1264
1265   // Reserve some memory inside the render queue
1266   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1267
1268   // Construct message in the render queue memory; note that delete should not be called on the return value
1269   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemovePropertyBuffer, propertyBuffer );
1270 }
1271
1272 void UpdateManager::SetPropertyBufferFormat( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Render::PropertyBuffer::Format>& format )
1273 {
1274   // Message has ownership of format while in transit from update -> render
1275   typedef MessageValue2< RenderManager, Render::PropertyBuffer*, OwnerPointer< Render::PropertyBuffer::Format > > DerivedType;
1276
1277   // Reserve some memory inside the render queue
1278   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1279
1280   // Construct message in the render queue memory; note that delete should not be called on the return value
1281   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetPropertyBufferFormat, propertyBuffer, format );
1282 }
1283
1284 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Vector<uint8_t> >& data, uint32_t size )
1285 {
1286   // Message has ownership of format while in transit from update -> render
1287   typedef MessageValue3< RenderManager, Render::PropertyBuffer*, OwnerPointer< Dali::Vector<uint8_t> >, uint32_t > DerivedType;
1288
1289   // Reserve some memory inside the render queue
1290   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1291
1292   // Construct message in the render queue memory; note that delete should not be called on the return value
1293   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
1294 }
1295
1296 void UpdateManager::AddGeometry( OwnerPointer< Render::Geometry >& geometry )
1297 {
1298   // Message has ownership of format while in transit from update -> render
1299   typedef MessageValue1< RenderManager, OwnerPointer< Render::Geometry > > DerivedType;
1300
1301   // Reserve some memory inside the render queue
1302   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1303
1304   // Construct message in the render queue memory; note that delete should not be called on the return value
1305   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddGeometry, geometry );
1306 }
1307
1308 void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
1309 {
1310   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1311
1312   // Reserve some memory inside the render queue
1313   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1314
1315   // Construct message in the render queue memory; note that delete should not be called on the return value
1316   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveGeometry, geometry );
1317 }
1318
1319 void UpdateManager::SetGeometryType( Render::Geometry* geometry, uint32_t geometryType )
1320 {
1321   typedef MessageValue2< RenderManager, Render::Geometry*, uint32_t > DerivedType;
1322
1323   // Reserve some memory inside the render queue
1324   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1325
1326   // Construct message in the render queue memory; note that delete should not be called on the return value
1327   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryType, geometry, geometryType );
1328 }
1329
1330 void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<uint16_t>& indices )
1331 {
1332   typedef IndexBufferMessage< RenderManager > DerivedType;
1333
1334   // Reserve some memory inside the render queue
1335   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1336
1337   // Construct message in the render queue memory; note that delete should not be called on the return value
1338   new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
1339 }
1340
1341 void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1342 {
1343   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1344
1345   // Reserve some memory inside the render queue
1346   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1347
1348   // Construct message in the render queue memory; note that delete should not be called on the return value
1349   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveVertexBuffer, geometry, propertyBuffer );
1350 }
1351
1352 void UpdateManager::AttachVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1353 {
1354   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1355
1356   // Reserve some memory inside the render queue
1357   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1358
1359   // Construct message in the render queue memory; note that delete should not be called on the return value
1360   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachVertexBuffer, geometry, propertyBuffer );
1361 }
1362
1363 void UpdateManager::AddTexture( OwnerPointer< Render::Texture >& texture )
1364 {
1365   // Message has ownership of Texture while in transit from update -> render
1366   typedef MessageValue1< RenderManager, OwnerPointer< Render::Texture > > DerivedType;
1367
1368   // Reserve some memory inside the render queue
1369   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1370
1371   // Construct message in the render queue memory; note that delete should not be called on the return value
1372   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddTexture, texture );
1373 }
1374
1375 void UpdateManager::RemoveTexture( Render::Texture* texture)
1376 {
1377   typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
1378
1379   // Reserve some memory inside the render queue
1380   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1381
1382   // Construct message in the render queue memory; note that delete should not be called on the return value
1383   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveTexture, texture );
1384 }
1385
1386 void UpdateManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
1387 {
1388   typedef MessageValue3< RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > DerivedType;
1389
1390   // Reserve some memory inside the message queue
1391   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1392
1393   // Construct message in the message queue memory; note that delete should not be called on the return value
1394   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params );
1395 }
1396
1397 void UpdateManager::GenerateMipmaps( Render::Texture* texture )
1398 {
1399   typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
1400
1401   // Reserve some memory inside the render queue
1402   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1403
1404   // Construct message in the render queue memory; note that delete should not be called on the return value
1405   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::GenerateMipmaps, texture );
1406 }
1407
1408 void UpdateManager::AddFrameBuffer( OwnerPointer< Render::FrameBuffer >& frameBuffer )
1409 {
1410   typedef MessageValue1< RenderManager, OwnerPointer< Render::FrameBuffer > > DerivedType;
1411
1412   // Reserve some memory inside the render queue
1413   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1414
1415   // Construct message in the render queue memory; note that delete should not be called on the return value
1416   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddFrameBuffer, frameBuffer );
1417 }
1418
1419 void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
1420 {
1421   typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
1422
1423   // Reserve some memory inside the render queue
1424   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1425
1426   // Construct message in the render queue memory; note that delete should not be called on the return value
1427   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveFrameBuffer, frameBuffer );
1428 }
1429
1430 void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
1431 {
1432   typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t > DerivedType;
1433
1434   // Reserve some memory inside the render queue
1435   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1436
1437   // Construct message in the render queue memory; note that delete should not be called on the return value
1438   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer );
1439 }
1440
1441 void UpdateManager::AttachDepthTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
1442 {
1443   typedef MessageValue3< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t > DerivedType;
1444
1445   // Reserve some memory inside the render queue
1446   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1447
1448   // Construct message in the render queue memory; note that delete should not be called on the return value
1449   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachDepthTextureToFrameBuffer, frameBuffer, texture, mipmapLevel );
1450 }
1451
1452 void UpdateManager::AttachDepthStencilTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
1453 {
1454   typedef MessageValue3< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t > DerivedType;
1455
1456   // Reserve some memory inside the render queue
1457   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1458
1459   // Construct message in the render queue memory; note that delete should not be called on the return value
1460   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachDepthStencilTextureToFrameBuffer, frameBuffer, texture, mipmapLevel );
1461 }
1462
1463 } // namespace SceneGraph
1464
1465 } // namespace Internal
1466
1467 } // namespace Dali