[Tizen] Add screen and client rotation itself function
[platform/core/uifw/dali-core.git] / 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     // Set dirty flags for next frame to continue rendering
1043     mImpl->nodeDirtyFlags |= RenderableUpdateFlags;
1044   }
1045
1046   // tell the update manager that we're done so the queue can be given to event thread
1047   mImpl->notificationManager.UpdateCompleted();
1048
1049   // The update has finished; swap the double-buffering indices
1050   mSceneGraphBuffers.Swap();
1051
1052   return keepUpdating;
1053 }
1054
1055 uint32_t UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const
1056 {
1057   // Update the duration set via Stage::KeepRendering()
1058   if ( mImpl->keepRenderingSeconds > 0.0f )
1059   {
1060     mImpl->keepRenderingSeconds -= elapsedSeconds;
1061   }
1062
1063   uint32_t keepUpdatingRequest = KeepUpdating::NOT_REQUESTED;
1064
1065   // If the rendering behavior is set to continuously render, then continue to render.
1066   // If Stage::KeepRendering() has been called, then continue until the duration has elapsed.
1067   // Keep updating until no messages are received and no animations are running.
1068   // If an animation has just finished, update at least once more for Discard end-actions.
1069   // No need to check for renderQueue as there is always a render after update and if that
1070   // render needs another update it will tell the adaptor to call update again
1071
1072   if ( ( mImpl->renderingBehavior == DevelStage::Rendering::CONTINUOUSLY ) ||
1073        ( mImpl->keepRenderingSeconds > 0.0f ) )
1074   {
1075     keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING;
1076   }
1077
1078   if ( IsAnimationRunning() ||
1079        mImpl->animationFinishedDuringUpdate )
1080   {
1081     keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING;
1082   }
1083
1084   if ( mImpl->renderTaskWaiting )
1085   {
1086     keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC;
1087   }
1088
1089   return keepUpdatingRequest;
1090 }
1091
1092 void UpdateManager::SetDefaultSurfaceRect( const Rect<int32_t>& rect )
1093 {
1094   mImpl->surfaceRectChanged = true;
1095
1096   typedef MessageValue1< RenderManager, Rect<int32_t> > DerivedType;
1097
1098   // Reserve some memory inside the render queue
1099   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1100
1101   // Construct message in the render queue memory; note that delete should not be called on the return value
1102   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceRect, rect );
1103 }
1104
1105 void UpdateManager::SetDefaultSurfaceOrientation( int orientation )
1106 {
1107   typedef MessageValue1< RenderManager, int > DerivedType;
1108
1109   // Reserve some memory inside the render queue
1110   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1111
1112   // Construct message in the render queue memory; note that delete should not be called on the return value
1113   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceOrientation, orientation );
1114 }
1115
1116 void UpdateManager::KeepRendering( float durationSeconds )
1117 {
1118   mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds );
1119 }
1120
1121 void UpdateManager::SetRenderingBehavior( DevelStage::Rendering renderingBehavior )
1122 {
1123   mImpl->renderingBehavior = renderingBehavior;
1124 }
1125
1126 void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, const Layer* rootLayer )
1127 {
1128   for ( auto&& scene : mImpl->scenes )
1129   {
1130     if ( scene && scene->root == rootLayer )
1131     {
1132       scene->sortedLayerList = layers;
1133       break;
1134     }
1135   }
1136 }
1137
1138 void UpdateManager::SetDepthIndices( OwnerPointer< NodeDepths >& nodeDepths )
1139 {
1140   // note,this vector is already in depth order. It could be used as-is to
1141   // remove sorting in update algorithm. However, it lacks layer boundary markers.
1142   for( auto&& iter : nodeDepths->nodeDepths )
1143   {
1144     iter.node->SetDepthIndex( iter.sortedDepth );
1145   }
1146
1147   for ( auto&& scene : mImpl->scenes )
1148   {
1149     if ( scene )
1150     {
1151       // Go through node hierarchy and rearrange siblings according to depth-index
1152       SortSiblingNodesRecursively( *scene->root );
1153     }
1154   }
1155 }
1156
1157 bool UpdateManager::IsDefaultSurfaceRectChanged()
1158 {
1159   bool surfaceRectChanged = mImpl->surfaceRectChanged;
1160
1161   // Reset the flag
1162   mImpl->surfaceRectChanged = false;
1163
1164   return surfaceRectChanged;
1165 }
1166
1167 void UpdateManager::AddFrameCallback( OwnerPointer< FrameCallback >& frameCallback, const Node* rootNode )
1168 {
1169   mImpl->GetFrameCallbackProcessor( *this ).AddFrameCallback( frameCallback, rootNode );
1170 }
1171
1172 void UpdateManager::RemoveFrameCallback( FrameCallbackInterface* frameCallback )
1173 {
1174   mImpl->GetFrameCallbackProcessor( *this ).RemoveFrameCallback( frameCallback );
1175 }
1176
1177 void UpdateManager::AddSampler( OwnerPointer< Render::Sampler >& sampler )
1178 {
1179   // Message has ownership of Sampler while in transit from update to render
1180   typedef MessageValue1< RenderManager, OwnerPointer< Render::Sampler > > DerivedType;
1181
1182   // Reserve some memory inside the render queue
1183   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1184
1185   // Construct message in the render queue memory; note that delete should not be called on the return value
1186   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddSampler, sampler );
1187 }
1188
1189 void UpdateManager::RemoveSampler( Render::Sampler* sampler )
1190 {
1191   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1192
1193   // Reserve some memory inside the render queue
1194   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1195
1196   // Construct message in the render queue memory; note that delete should not be called on the return value
1197   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveSampler, sampler );
1198 }
1199
1200 void UpdateManager::SetFilterMode( Render::Sampler* sampler, uint32_t minFilterMode, uint32_t magFilterMode )
1201 {
1202   typedef MessageValue3< RenderManager, Render::Sampler*, uint32_t, uint32_t > DerivedType;
1203
1204   // Reserve some memory inside the render queue
1205   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1206
1207   // Construct message in the render queue memory; note that delete should not be called on the return value
1208   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
1209 }
1210
1211 void UpdateManager::SetWrapMode( Render::Sampler* sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode )
1212 {
1213   typedef MessageValue4< RenderManager, Render::Sampler*, uint32_t, uint32_t, uint32_t > DerivedType;
1214
1215   // Reserve some memory inside the render queue
1216   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1217
1218   // Construct message in the render queue memory; note that delete should not be called on the return value
1219   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode );
1220 }
1221
1222 void UpdateManager::AddPropertyBuffer( OwnerPointer< Render::PropertyBuffer >& propertyBuffer )
1223 {
1224   // Message has ownership of format while in transit from update -> render
1225   typedef MessageValue1< RenderManager, OwnerPointer< Render::PropertyBuffer > > DerivedType;
1226
1227   // Reserve some memory inside the render queue
1228   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1229
1230   // Construct message in the render queue memory; note that delete should not be called on the return value
1231   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddPropertyBuffer, propertyBuffer );
1232 }
1233
1234 void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1235 {
1236   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1237
1238   // Reserve some memory inside the render queue
1239   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1240
1241   // Construct message in the render queue memory; note that delete should not be called on the return value
1242   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemovePropertyBuffer, propertyBuffer );
1243 }
1244
1245 void UpdateManager::SetPropertyBufferFormat( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Render::PropertyBuffer::Format>& format )
1246 {
1247   // Message has ownership of format while in transit from update -> render
1248   typedef MessageValue2< RenderManager, Render::PropertyBuffer*, OwnerPointer< Render::PropertyBuffer::Format > > DerivedType;
1249
1250   // Reserve some memory inside the render queue
1251   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1252
1253   // Construct message in the render queue memory; note that delete should not be called on the return value
1254   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetPropertyBufferFormat, propertyBuffer, format );
1255 }
1256
1257 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Vector<uint8_t> >& data, uint32_t size )
1258 {
1259   // Message has ownership of format while in transit from update -> render
1260   typedef MessageValue3< RenderManager, Render::PropertyBuffer*, OwnerPointer< Dali::Vector<uint8_t> >, uint32_t > DerivedType;
1261
1262   // Reserve some memory inside the render queue
1263   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1264
1265   // Construct message in the render queue memory; note that delete should not be called on the return value
1266   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
1267 }
1268
1269 void UpdateManager::AddGeometry( OwnerPointer< Render::Geometry >& geometry )
1270 {
1271   // Message has ownership of format while in transit from update -> render
1272   typedef MessageValue1< RenderManager, OwnerPointer< Render::Geometry > > DerivedType;
1273
1274   // Reserve some memory inside the render queue
1275   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1276
1277   // Construct message in the render queue memory; note that delete should not be called on the return value
1278   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddGeometry, geometry );
1279 }
1280
1281 void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
1282 {
1283   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1284
1285   // Reserve some memory inside the render queue
1286   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1287
1288   // Construct message in the render queue memory; note that delete should not be called on the return value
1289   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveGeometry, geometry );
1290 }
1291
1292 void UpdateManager::SetGeometryType( Render::Geometry* geometry, uint32_t geometryType )
1293 {
1294   typedef MessageValue2< RenderManager, Render::Geometry*, uint32_t > DerivedType;
1295
1296   // Reserve some memory inside the render queue
1297   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1298
1299   // Construct message in the render queue memory; note that delete should not be called on the return value
1300   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryType, geometry, geometryType );
1301 }
1302
1303 void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<uint16_t>& indices )
1304 {
1305   typedef IndexBufferMessage< RenderManager > DerivedType;
1306
1307   // Reserve some memory inside the render queue
1308   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1309
1310   // Construct message in the render queue memory; note that delete should not be called on the return value
1311   new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
1312 }
1313
1314 void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1315 {
1316   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1317
1318   // Reserve some memory inside the render queue
1319   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1320
1321   // Construct message in the render queue memory; note that delete should not be called on the return value
1322   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveVertexBuffer, geometry, propertyBuffer );
1323 }
1324
1325 void UpdateManager::AttachVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1326 {
1327   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1328
1329   // Reserve some memory inside the render queue
1330   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1331
1332   // Construct message in the render queue memory; note that delete should not be called on the return value
1333   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachVertexBuffer, geometry, propertyBuffer );
1334 }
1335
1336 void UpdateManager::AddTexture( OwnerPointer< Render::Texture >& texture )
1337 {
1338   // Message has ownership of Texture while in transit from update -> render
1339   typedef MessageValue1< RenderManager, OwnerPointer< Render::Texture > > DerivedType;
1340
1341   // Reserve some memory inside the render queue
1342   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1343
1344   // Construct message in the render queue memory; note that delete should not be called on the return value
1345   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddTexture, texture );
1346 }
1347
1348 void UpdateManager::RemoveTexture( Render::Texture* texture)
1349 {
1350   typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
1351
1352   // Reserve some memory inside the render queue
1353   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1354
1355   // Construct message in the render queue memory; note that delete should not be called on the return value
1356   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveTexture, texture );
1357 }
1358
1359 void UpdateManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
1360 {
1361   typedef MessageValue3< RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > DerivedType;
1362
1363   // Reserve some memory inside the message queue
1364   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1365
1366   // Construct message in the message queue memory; note that delete should not be called on the return value
1367   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params );
1368 }
1369
1370 void UpdateManager::GenerateMipmaps( Render::Texture* texture )
1371 {
1372   typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
1373
1374   // Reserve some memory inside the render queue
1375   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1376
1377   // Construct message in the render queue memory; note that delete should not be called on the return value
1378   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::GenerateMipmaps, texture );
1379 }
1380
1381 void UpdateManager::AddFrameBuffer( OwnerPointer< Render::FrameBuffer >& frameBuffer )
1382 {
1383   typedef MessageValue1< RenderManager, OwnerPointer< Render::FrameBuffer > > DerivedType;
1384
1385   // Reserve some memory inside the render queue
1386   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1387
1388   // Construct message in the render queue memory; note that delete should not be called on the return value
1389   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddFrameBuffer, frameBuffer );
1390 }
1391
1392 void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
1393 {
1394   typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
1395
1396   // Reserve some memory inside the render queue
1397   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1398
1399   // Construct message in the render queue memory; note that delete should not be called on the return value
1400   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveFrameBuffer, frameBuffer );
1401 }
1402
1403 void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
1404 {
1405   typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t > DerivedType;
1406
1407   // Reserve some memory inside the render queue
1408   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1409
1410   // Construct message in the render queue memory; note that delete should not be called on the return value
1411   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer );
1412 }
1413
1414 } // namespace SceneGraph
1415
1416 } // namespace Internal
1417
1418 } // namespace Dali