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 all root nodes dirty flags
 697   for( auto& scene : mImpl->scenes )
 698   {
 699     auto root = scene->root;
 700     root->ResetDirtyFlags( bufferIndex );
 701   }
 702
 703   // Clear node dirty flags
 704   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
 705   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
 706   for( ;iter != endIter; ++iter )
 707   {
 708     (*iter)->ResetDirtyFlags( bufferIndex );
 709   }
 710 }
 711
 712 bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, uint32_t lastVSyncTimeMilliseconds, uint32_t nextVSyncTimeMilliseconds )
 713 {
 714   bool gestureUpdated( false );
 715
 716   if( mImpl->panGestureProcessor )
 717   {
 718     // gesture processor only supports default properties
 719     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
 720     gestureUpdated |= mImpl->panGestureProcessor->UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 721   }
 722
 723   return gestureUpdated;
 724 }
 725
 726 void UpdateManager::Animate( BufferIndex bufferIndex, float elapsedSeconds )
 727 {
 728   auto&& iter = mImpl->animations.Begin();
 729   bool animationLooped = false;
 730
 731   while ( iter != mImpl->animations.End() )
 732   {
 733     Animation* animation = *iter;
 734     bool finished = false;
 735     bool looped = false;
 736     bool progressMarkerReached = false;
 737     animation->Update( bufferIndex, elapsedSeconds, looped, finished, progressMarkerReached );
 738
 739     if ( progressMarkerReached )
 740     {
 741       mImpl->notificationManager.QueueMessage( Internal::NotifyProgressReachedMessage( mImpl->animationPlaylist, animation ) );
 742     }
 743
 744     mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || finished;
 745     animationLooped = animationLooped || looped;
 746
 747     // Remove animations that had been destroyed but were still waiting for an update
 748     if (animation->GetState() == Animation::Destroyed)
 749     {
 750       iter = mImpl->animations.Erase(iter);
 751     }
 752     else
 753     {
 754       ++iter;
 755     }
 756   }
 757
 758   // queue the notification on finished or looped (to update loop count)
 759   if ( mImpl->animationFinishedDuringUpdate || animationLooped )
 760   {
 761     // The application should be notified by NotificationManager, in another thread
 762     mImpl->notificationManager.QueueCompleteNotification( &mImpl->animationPlaylist );
 763   }
 764 }
 765
 766 void UpdateManager::ConstrainCustomObjects( BufferIndex bufferIndex )
 767 {
 768   //Constrain custom objects (in construction order)
 769   for ( auto&& object : mImpl->customObjects )
 770   {
 771     ConstrainPropertyOwner( *object, bufferIndex );
 772   }
 773 }
 774
 775 void UpdateManager::ConstrainRenderTasks( BufferIndex bufferIndex )
 776 {
 777   // Constrain render-tasks
 778   for ( auto&& scene : mImpl->scenes )
 779   {
 780     if ( scene && scene->taskList )
 781     {
 782       RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks();
 783       for ( auto&& task : tasks )
 784       {
 785         ConstrainPropertyOwner( *task, bufferIndex );
 786       }
 787     }
 788   }
 789 }
 790
 791 void UpdateManager::ConstrainShaders( BufferIndex bufferIndex )
 792 {
 793   // constrain shaders... (in construction order)
 794   for ( auto&& shader : mImpl->shaders )
 795   {
 796     ConstrainPropertyOwner( *shader, bufferIndex );
 797   }
 798 }
 799
 800 void UpdateManager::ProcessPropertyNotifications( BufferIndex bufferIndex )
 801 {
 802   for( auto&& notification : mImpl->propertyNotifications )
 803   {
 804     bool valid = notification->Check( bufferIndex );
 805     if(valid)
 806     {
 807       mImpl->notificationManager.QueueMessage( PropertyChangedMessage( mImpl->propertyNotifier, notification, notification->GetValidity() ) );
 808     }
 809   }
 810 }
 811
 812 void UpdateManager::ForwardCompiledShadersToEventThread()
 813 {
 814   DALI_ASSERT_DEBUG( (mImpl->shaderSaver != 0) && "shaderSaver should be wired-up during startup." );
 815   if( mImpl->shaderSaver )
 816   {
 817     // lock and swap the queues
 818     {
 819       // render might be attempting to send us more binaries at the same time
 820       Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
 821       mImpl->renderCompiledShaders.swap( mImpl->updateCompiledShaders );
 822     }
 823
 824     if( mImpl->updateCompiledShaders.size() > 0 )
 825     {
 826       ShaderSaver& factory = *mImpl->shaderSaver;
 827       for( auto&& shader : mImpl->updateCompiledShaders )
 828       {
 829         mImpl->notificationManager.QueueMessage( ShaderCompiledMessage( factory, shader ) );
 830       }
 831       // we don't need them in update anymore
 832       mImpl->updateCompiledShaders.clear();
 833     }
 834   }
 835 }
 836
 837 void UpdateManager::UpdateRenderers( BufferIndex bufferIndex )
 838 {
 839   for( auto&& renderer : mImpl->renderers )
 840   {
 841     //Apply constraints
 842     ConstrainPropertyOwner( *renderer, bufferIndex );
 843
 844     renderer->PrepareRender( bufferIndex );
 845   }
 846 }
 847
 848 void UpdateManager::UpdateNodes( BufferIndex bufferIndex )
 849 {
 850   mImpl->nodeDirtyFlags = NodePropertyFlags::NOTHING;
 851
 852   for ( auto&& scene : mImpl->scenes )
 853   {
 854     if ( scene && scene->root )
 855     {
 856       // Prepare resources, update shaders, for each node
 857       // And add the renderers to the sorted layers. Start from root, which is also a layer
 858       mImpl->nodeDirtyFlags |= UpdateNodeTree( *scene->root,
 859                                               bufferIndex,
 860                                               mImpl->renderQueue );
 861     }
 862   }
 863 }
 864
 865 uint32_t UpdateManager::Update( float elapsedSeconds,
 866                                 uint32_t lastVSyncTimeMilliseconds,
 867                                 uint32_t nextVSyncTimeMilliseconds,
 868                                 bool renderToFboEnabled,
 869                                 bool isRenderingToFbo )
 870 {
 871   const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
 872
 873   //Clear nodes/resources which were previously discarded
 874   mImpl->discardQueue.Clear( bufferIndex );
 875
 876   //Process Touches & Gestures
 877   const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 878
 879   bool updateScene = // The scene-graph requires an update if..
 880       (mImpl->nodeDirtyFlags & RenderableUpdateFlags) ||    // ..nodes were dirty in previous frame OR
 881       IsAnimationRunning()                            ||    // ..at least one animation is running OR
 882       mImpl->messageQueue.IsSceneUpdateRequired()     ||    // ..a message that modifies the scene graph node tree is queued OR
 883       gestureUpdated;                                       // ..a gesture property was updated
 884
 885   bool keepRendererRendering = false;
 886
 887   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 888   // values if the scene was updated in the previous frame.
 889   if( updateScene || mImpl->previousUpdateScene )
 890   {
 891     //Reset properties from the previous update
 892     ResetProperties( bufferIndex );
 893     mImpl->transformManager.ResetToBaseValue();
 894   }
 895
 896   // Process the queued scene messages. Note, MessageQueue::FlushQueue may be called
 897   // between calling IsSceneUpdateRequired() above and here, so updateScene should
 898   // be set again
 899   updateScene |= mImpl->messageQueue.ProcessMessages( bufferIndex );
 900
 901   //Forward compiled shader programs to event thread for saving
 902   ForwardCompiledShadersToEventThread();
 903
 904   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 905   // renderer lists if the scene was updated in the previous frame.
 906   // We should not start skipping update steps or reusing lists until there has been two frames where nothing changes
 907   if( updateScene || mImpl->previousUpdateScene )
 908   {
 909     //Animate
 910     Animate( bufferIndex, elapsedSeconds );
 911
 912     //Constraint custom objects
 913     ConstrainCustomObjects( bufferIndex );
 914
 915     //Clear the lists of renderers from the previous update
 916     for( auto&& scene : mImpl->scenes )
 917     {
 918       if ( scene )
 919       {
 920         for( auto&& layer : scene->sortedLayerList )
 921         {
 922           if ( layer )
 923           {
 924             layer->ClearRenderables();
 925           }
 926         }
 927       }
 928     }
 929
 930     // Call the frame-callback-processor if set
 931     if( mImpl->frameCallbackProcessor )
 932     {
 933       mImpl->frameCallbackProcessor->Update( bufferIndex, elapsedSeconds );
 934     }
 935
 936     //Update node hierarchy, apply constraints and perform sorting / culling.
 937     //This will populate each Layer with a list of renderers which are ready.
 938     UpdateNodes( bufferIndex );
 939
 940     //Apply constraints to RenderTasks, shaders
 941     ConstrainRenderTasks( bufferIndex );
 942     ConstrainShaders( bufferIndex );
 943
 944     //Update renderers and apply constraints
 945     UpdateRenderers( bufferIndex );
 946
 947     //Update the transformations of all the nodes
 948     mImpl->transformManager.Update();
 949
 950     //Process Property Notifications
 951     ProcessPropertyNotifications( bufferIndex );
 952
 953     //Update cameras
 954     for( auto&& cameraIterator : mImpl->cameras )
 955     {
 956       cameraIterator->Update( bufferIndex );
 957     }
 958
 959     //Process the RenderTasks if renderers exist. This creates the instructions for rendering the next frame.
 960     //reset the update buffer index and make sure there is enough room in the instruction container
 961     if( mImpl->renderersAdded )
 962     {
 963       // Calculate how many render tasks we have in total
 964       std::size_t numberOfRenderTasks = 0;
 965       for (auto&& scene : mImpl->scenes )
 966       {
 967         if ( scene && scene->taskList )
 968         {
 969           numberOfRenderTasks += scene->taskList->GetTasks().Count();
 970         }
 971       }
 972
 973       mImpl->renderInstructions.ResetAndReserve( bufferIndex,
 974                                                  static_cast<uint32_t>( numberOfRenderTasks ) );
 975
 976       for ( auto&& scene : mImpl->scenes )
 977       {
 978         if ( scene && scene->root && scene->taskList )
 979         {
 980           keepRendererRendering |= mImpl->renderTaskProcessor.Process( bufferIndex,
 981                                               *scene->taskList,
 982                                               *scene->root,
 983                                               scene->sortedLayerList,
 984                                               mImpl->renderInstructions,
 985                                               renderToFboEnabled,
 986                                               isRenderingToFbo );
 987         }
 988       }
 989
 990       DALI_LOG_INFO( gLogFilter, Debug::General,
 991                      "Update: numberOfRenderTasks(%d), Render Instructions(%d)\n",
 992                      numberOfRenderTasks, mImpl->renderInstructions.Count( bufferIndex ) );
 993     }
 994   }
 995
 996   for ( auto&& scene : mImpl->scenes )
 997   {
 998     if ( scene && scene->root && scene->taskList )
 999     {
1000       RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks();
1001
1002       // check the countdown and notify
1003       bool doRenderOnceNotify = false;
1004       mImpl->renderTaskWaiting = false;
1005       for ( auto&& renderTask : tasks )
1006       {
1007         renderTask->UpdateState();
1008
1009         if( renderTask->IsWaitingToRender() &&
1010             renderTask->ReadyToRender( bufferIndex ) /*avoid updating forever when source actor is off-stage*/ )
1011         {
1012           mImpl->renderTaskWaiting = true; // keep update/render threads alive
1013         }
1014
1015         if( renderTask->HasRendered() )
1016         {
1017           doRenderOnceNotify = true;
1018         }
1019       }
1020
1021       if( doRenderOnceNotify )
1022       {
1023         DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n");
1024         mImpl->notificationManager.QueueCompleteNotification( scene->taskList->GetCompleteNotificationInterface() );
1025       }
1026     }
1027   }
1028
1029   // Macro is undefined in release build.
1030   SNAPSHOT_NODE_LOGGING;
1031
1032   // A ResetProperties() may be required in the next frame
1033   mImpl->previousUpdateScene = updateScene;
1034
1035   // Check whether further updates are required
1036   uint32_t keepUpdating = KeepUpdatingCheck( elapsedSeconds );
1037
1038   if( keepRendererRendering )
1039   {
1040     keepUpdating |= KeepUpdating::STAGE_KEEP_RENDERING;
1041   }
1042
1043   // tell the update manager that we're done so the queue can be given to event thread
1044   mImpl->notificationManager.UpdateCompleted();
1045
1046   // The update has finished; swap the double-buffering indices
1047   mSceneGraphBuffers.Swap();
1048
1049   return keepUpdating;
1050 }
1051
1052 uint32_t UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const
1053 {
1054   // Update the duration set via Stage::KeepRendering()
1055   if ( mImpl->keepRenderingSeconds > 0.0f )
1056   {
1057     mImpl->keepRenderingSeconds -= elapsedSeconds;
1058   }
1059
1060   uint32_t keepUpdatingRequest = KeepUpdating::NOT_REQUESTED;
1061
1062   // If the rendering behavior is set to continuously render, then continue to render.
1063   // If Stage::KeepRendering() has been called, then continue until the duration has elapsed.
1064   // Keep updating until no messages are received and no animations are running.
1065   // If an animation has just finished, update at least once more for Discard end-actions.
1066   // No need to check for renderQueue as there is always a render after update and if that
1067   // render needs another update it will tell the adaptor to call update again
1068
1069   if ( ( mImpl->renderingBehavior == DevelStage::Rendering::CONTINUOUSLY ) ||
1070        ( mImpl->keepRenderingSeconds > 0.0f ) )
1071   {
1072     keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING;
1073   }
1074
1075   if ( IsAnimationRunning() ||
1076        mImpl->animationFinishedDuringUpdate )
1077   {
1078     keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING;
1079   }
1080
1081   if ( mImpl->renderTaskWaiting )
1082   {
1083     keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC;
1084   }
1085
1086   return keepUpdatingRequest;
1087 }
1088
1089 void UpdateManager::SetBackgroundColor( const Vector4& color )
1090 {
1091   typedef MessageValue1< RenderManager, Vector4 > DerivedType;
1092
1093   // Reserve some memory inside the render queue
1094   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1095
1096   // Construct message in the render queue memory; note that delete should not be called on the return value
1097   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetBackgroundColor, color );
1098 }
1099
1100 void UpdateManager::SetDefaultSurfaceRect( const Rect<int32_t>& rect )
1101 {
1102   mImpl->surfaceRectChanged = true;
1103
1104   typedef MessageValue1< RenderManager, Rect<int32_t> > DerivedType;
1105
1106   // Reserve some memory inside the render queue
1107   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1108
1109   // Construct message in the render queue memory; note that delete should not be called on the return value
1110   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceRect, rect );
1111 }
1112
1113 void UpdateManager::KeepRendering( float durationSeconds )
1114 {
1115   mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds );
1116 }
1117
1118 void UpdateManager::SetRenderingBehavior( DevelStage::Rendering renderingBehavior )
1119 {
1120   mImpl->renderingBehavior = renderingBehavior;
1121 }
1122
1123 void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, const Layer* rootLayer )
1124 {
1125   for ( auto&& scene : mImpl->scenes )
1126   {
1127     if ( scene && scene->root == rootLayer )
1128     {
1129       scene->sortedLayerList = layers;
1130       break;
1131     }
1132   }
1133 }
1134
1135 void UpdateManager::SetDepthIndices( OwnerPointer< NodeDepths >& nodeDepths )
1136 {
1137   // note,this vector is already in depth order. It could be used as-is to
1138   // remove sorting in update algorithm. However, it lacks layer boundary markers.
1139   for( auto&& iter : nodeDepths->nodeDepths )
1140   {
1141     iter.node->SetDepthIndex( iter.sortedDepth );
1142   }
1143
1144   for ( auto&& scene : mImpl->scenes )
1145   {
1146     if ( scene )
1147     {
1148       // Go through node hierarchy and rearrange siblings according to depth-index
1149       SortSiblingNodesRecursively( *scene->root );
1150     }
1151   }
1152 }
1153
1154 bool UpdateManager::IsDefaultSurfaceRectChanged()
1155 {
1156   bool surfaceRectChanged = mImpl->surfaceRectChanged;
1157
1158   // Reset the flag
1159   mImpl->surfaceRectChanged = false;
1160
1161   return surfaceRectChanged;
1162 }
1163
1164 void UpdateManager::AddFrameCallback( OwnerPointer< FrameCallback >& frameCallback, const Node* rootNode )
1165 {
1166   mImpl->GetFrameCallbackProcessor( *this ).AddFrameCallback( frameCallback, rootNode );
1167 }
1168
1169 void UpdateManager::RemoveFrameCallback( FrameCallbackInterface* frameCallback )
1170 {
1171   mImpl->GetFrameCallbackProcessor( *this ).RemoveFrameCallback( frameCallback );
1172 }
1173
1174 void UpdateManager::AddSampler( OwnerPointer< Render::Sampler >& sampler )
1175 {
1176   // Message has ownership of Sampler while in transit from update to render
1177   typedef MessageValue1< RenderManager, OwnerPointer< Render::Sampler > > DerivedType;
1178
1179   // Reserve some memory inside the render queue
1180   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1181
1182   // Construct message in the render queue memory; note that delete should not be called on the return value
1183   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddSampler, sampler );
1184 }
1185
1186 void UpdateManager::RemoveSampler( Render::Sampler* sampler )
1187 {
1188   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1189
1190   // Reserve some memory inside the render queue
1191   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1192
1193   // Construct message in the render queue memory; note that delete should not be called on the return value
1194   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveSampler, sampler );
1195 }
1196
1197 void UpdateManager::SetFilterMode( Render::Sampler* sampler, uint32_t minFilterMode, uint32_t magFilterMode )
1198 {
1199   typedef MessageValue3< RenderManager, Render::Sampler*, uint32_t, uint32_t > DerivedType;
1200
1201   // Reserve some memory inside the render queue
1202   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1203
1204   // Construct message in the render queue memory; note that delete should not be called on the return value
1205   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
1206 }
1207
1208 void UpdateManager::SetWrapMode( Render::Sampler* sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode )
1209 {
1210   typedef MessageValue4< RenderManager, Render::Sampler*, uint32_t, uint32_t, uint32_t > DerivedType;
1211
1212   // Reserve some memory inside the render queue
1213   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1214
1215   // Construct message in the render queue memory; note that delete should not be called on the return value
1216   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode );
1217 }
1218
1219 void UpdateManager::AddPropertyBuffer( OwnerPointer< Render::PropertyBuffer >& propertyBuffer )
1220 {
1221   // Message has ownership of format while in transit from update -> render
1222   typedef MessageValue1< RenderManager, OwnerPointer< Render::PropertyBuffer > > DerivedType;
1223
1224   // Reserve some memory inside the render queue
1225   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1226
1227   // Construct message in the render queue memory; note that delete should not be called on the return value
1228   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddPropertyBuffer, propertyBuffer );
1229 }
1230
1231 void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1232 {
1233   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1234
1235   // Reserve some memory inside the render queue
1236   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1237
1238   // Construct message in the render queue memory; note that delete should not be called on the return value
1239   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemovePropertyBuffer, propertyBuffer );
1240 }
1241
1242 void UpdateManager::SetPropertyBufferFormat( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Render::PropertyBuffer::Format>& format )
1243 {
1244   // Message has ownership of format while in transit from update -> render
1245   typedef MessageValue2< RenderManager, Render::PropertyBuffer*, OwnerPointer< Render::PropertyBuffer::Format > > DerivedType;
1246
1247   // Reserve some memory inside the render queue
1248   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1249
1250   // Construct message in the render queue memory; note that delete should not be called on the return value
1251   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetPropertyBufferFormat, propertyBuffer, format );
1252 }
1253
1254 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Vector<uint8_t> >& data, uint32_t size )
1255 {
1256   // Message has ownership of format while in transit from update -> render
1257   typedef MessageValue3< RenderManager, Render::PropertyBuffer*, OwnerPointer< Dali::Vector<uint8_t> >, uint32_t > DerivedType;
1258
1259   // Reserve some memory inside the render queue
1260   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1261
1262   // Construct message in the render queue memory; note that delete should not be called on the return value
1263   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
1264 }
1265
1266 void UpdateManager::AddGeometry( OwnerPointer< Render::Geometry >& geometry )
1267 {
1268   // Message has ownership of format while in transit from update -> render
1269   typedef MessageValue1< RenderManager, OwnerPointer< Render::Geometry > > DerivedType;
1270
1271   // Reserve some memory inside the render queue
1272   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1273
1274   // Construct message in the render queue memory; note that delete should not be called on the return value
1275   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddGeometry, geometry );
1276 }
1277
1278 void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
1279 {
1280   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1281
1282   // Reserve some memory inside the render queue
1283   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1284
1285   // Construct message in the render queue memory; note that delete should not be called on the return value
1286   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveGeometry, geometry );
1287 }
1288
1289 void UpdateManager::SetGeometryType( Render::Geometry* geometry, uint32_t geometryType )
1290 {
1291   typedef MessageValue2< RenderManager, Render::Geometry*, uint32_t > DerivedType;
1292
1293   // Reserve some memory inside the render queue
1294   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1295
1296   // Construct message in the render queue memory; note that delete should not be called on the return value
1297   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryType, geometry, geometryType );
1298 }
1299
1300 void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<uint16_t>& indices )
1301 {
1302   typedef IndexBufferMessage< RenderManager > DerivedType;
1303
1304   // Reserve some memory inside the render queue
1305   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1306
1307   // Construct message in the render queue memory; note that delete should not be called on the return value
1308   new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
1309 }
1310
1311 void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1312 {
1313   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1314
1315   // Reserve some memory inside the render queue
1316   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1317
1318   // Construct message in the render queue memory; note that delete should not be called on the return value
1319   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveVertexBuffer, geometry, propertyBuffer );
1320 }
1321
1322 void UpdateManager::AttachVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1323 {
1324   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1325
1326   // Reserve some memory inside the render queue
1327   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1328
1329   // Construct message in the render queue memory; note that delete should not be called on the return value
1330   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachVertexBuffer, geometry, propertyBuffer );
1331 }
1332
1333 void UpdateManager::AddTexture( OwnerPointer< Render::Texture >& texture )
1334 {
1335   // Message has ownership of Texture while in transit from update -> render
1336   typedef MessageValue1< RenderManager, OwnerPointer< Render::Texture > > DerivedType;
1337
1338   // Reserve some memory inside the render queue
1339   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1340
1341   // Construct message in the render queue memory; note that delete should not be called on the return value
1342   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddTexture, texture );
1343 }
1344
1345 void UpdateManager::RemoveTexture( Render::Texture* texture)
1346 {
1347   typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
1348
1349   // Reserve some memory inside the render queue
1350   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1351
1352   // Construct message in the render queue memory; note that delete should not be called on the return value
1353   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveTexture, texture );
1354 }
1355
1356 void UpdateManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
1357 {
1358   typedef MessageValue3< RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > DerivedType;
1359
1360   // Reserve some memory inside the message queue
1361   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1362
1363   // Construct message in the message queue memory; note that delete should not be called on the return value
1364   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params );
1365 }
1366
1367 void UpdateManager::GenerateMipmaps( Render::Texture* texture )
1368 {
1369   typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
1370
1371   // Reserve some memory inside the render queue
1372   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1373
1374   // Construct message in the render queue memory; note that delete should not be called on the return value
1375   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::GenerateMipmaps, texture );
1376 }
1377
1378 void UpdateManager::AddFrameBuffer( OwnerPointer< Render::FrameBuffer >& frameBuffer )
1379 {
1380   typedef MessageValue1< RenderManager, OwnerPointer< Render::FrameBuffer > > DerivedType;
1381
1382   // Reserve some memory inside the render queue
1383   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1384
1385   // Construct message in the render queue memory; note that delete should not be called on the return value
1386   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddFrameBuffer, frameBuffer );
1387 }
1388
1389 void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
1390 {
1391   typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
1392
1393   // Reserve some memory inside the render queue
1394   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1395
1396   // Construct message in the render queue memory; note that delete should not be called on the return value
1397   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveFrameBuffer, frameBuffer );
1398 }
1399
1400 void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
1401 {
1402   typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t > DerivedType;
1403
1404   // Reserve some memory inside the render queue
1405   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1406
1407   // Construct message in the render queue memory; note that delete should not be called on the return value
1408   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer );
1409 }
1410
1411 } // namespace SceneGraph
1412
1413 } // namespace Internal
1414
1415 } // namespace Dali