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

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