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