2 * Copyright (c) 2020 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <dali/internal/update/manager/update-manager.h>
22 #include <dali/integration-api/core.h>
24 #include <dali/internal/event/common/notification-manager.h>
25 #include <dali/internal/event/common/property-notifier.h>
26 #include <dali/internal/event/effects/shader-factory.h>
27 #include <dali/internal/event/animation/animation-playlist.h>
29 #include <dali/internal/update/common/discard-queue.h>
30 #include <dali/internal/update/controllers/render-message-dispatcher.h>
31 #include <dali/internal/update/controllers/scene-controller-impl.h>
32 #include <dali/internal/update/manager/frame-callback-processor.h>
33 #include <dali/internal/update/manager/render-task-processor.h>
34 #include <dali/internal/update/manager/update-algorithms.h>
35 #include <dali/internal/update/manager/update-manager-debug.h>
36 #include <dali/internal/update/manager/transform-manager.h>
37 #include <dali/internal/update/nodes/node.h>
38 #include <dali/internal/update/queue/update-message-queue.h>
40 #include <dali/internal/render/common/render-manager.h>
41 #include <dali/internal/render/queue/render-queue.h>
43 // Un-comment to enable node tree debug logging
44 //#define NODE_TREE_LOGGING 1
46 #if ( defined( DEBUG_ENABLED ) && defined( NODE_TREE_LOGGING ) )
47 #define SNAPSHOT_NODE_LOGGING \
48 const uint32_t FRAME_COUNT_TRIGGER = 16;\
49 if( mImpl->frameCounter >= FRAME_COUNT_TRIGGER )\
51 for( auto&& scene : mImpl->scenes )
53 if ( scene && scene->root )\
55 mImpl->frameCounter = 0;\
56 PrintNodeTree( *scene->root, mSceneGraphBuffers.GetUpdateBufferIndex(), "" );\
60 mImpl->frameCounter++;
62 #define SNAPSHOT_NODE_LOGGING
65 #if defined(DEBUG_ENABLED)
66 extern Debug::Filter* gRenderTaskLogFilter;
69 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_UPDATE_MANAGER" );
70 } // unnamed namespace
74 using namespace Dali::Integration;
75 using Dali::Internal::Update::MessageQueue;
89 * Helper to Erase an object from OwnerContainer using discard queue
90 * @param container to remove from
91 * @param object to remove
92 * @param discardQueue to put the object to
93 * @param updateBufferIndex to use
96 inline void EraseUsingDiscardQueue( OwnerContainer<T*>& container, T* object, DiscardQueue& discardQueue, BufferIndex updateBufferIndex )
98 DALI_ASSERT_DEBUG( object && "NULL object not allowed" );
100 // need to use the reference version of auto as we need the pointer to the pointer for the Release call below
101 for( auto&& iter : container )
103 if ( iter == object )
105 // Transfer ownership to the discard queue, this keeps the object alive, until the render-thread has finished with it
106 discardQueue.Add( updateBufferIndex, container.Release( &iter ) ); // take the address of the reference to a pointer (iter)
107 return; // return as we only ever remove one object. Iterators to container are now invalidated as well so cannot continue
113 * Descends into node's hierarchy and sorts the children of each child according to their depth-index.
114 * @param[in] node The node whose hierarchy to descend
116 void SortSiblingNodesRecursively( Node& node )
118 NodeContainer& container = node.GetChildren();
119 std::sort( container.Begin(), container.End(),
120 []( Node* a, Node* b ) { return a->GetDepthIndex() < b->GetDepthIndex(); } );
122 // Descend tree and sort as well
123 for( auto&& iter : container )
125 SortSiblingNodesRecursively( *iter );
129 } // unnamed namespace
132 * Structure to contain UpdateManager internal data
134 struct UpdateManager::Impl
136 // SceneInfo keeps the root node of the Scene, its scene graph render task list, and the list of Layer pointers sorted by depth
139 SceneInfo( Layer* root ) ///< Constructor
144 ~SceneInfo() = default; ///< Default non-virtual destructor
145 SceneInfo( SceneInfo&& rhs ) = default; ///< Move constructor
146 SceneInfo& operator=( SceneInfo&& rhs ) = default; ///< Move assignment operator
147 SceneInfo& operator=( const SceneInfo& rhs ) = delete; ///< Assignment operator
148 SceneInfo( const SceneInfo& rhs ) = delete; ///< Copy constructor
150 Layer* root{ nullptr }; ///< Root node (root is a layer). The layer is not stored in the node memory pool.
151 OwnerPointer< RenderTaskList > taskList; ///< Scene graph render task list
152 SortedLayerPointers sortedLayerList; ///< List of Layer pointers sorted by depth (one list of sorted layers per root)
153 OwnerPointer< Scene > scene; ///< Scene graph object of the scene
156 Impl( NotificationManager& notificationManager,
157 CompleteNotificationInterface& animationPlaylist,
158 PropertyNotifier& propertyNotifier,
159 DiscardQueue& discardQueue,
160 RenderController& renderController,
161 RenderManager& renderManager,
162 RenderQueue& renderQueue,
163 SceneGraphBuffers& sceneGraphBuffers,
164 RenderTaskProcessor& renderTaskProcessor )
165 : renderMessageDispatcher( renderManager, renderQueue, sceneGraphBuffers ),
166 notificationManager( notificationManager ),
168 animationPlaylist( animationPlaylist ),
169 propertyNotifier( propertyNotifier ),
171 discardQueue( discardQueue ),
172 renderController( renderController ),
173 sceneController( NULL ),
174 renderManager( renderManager ),
175 renderQueue( renderQueue ),
176 renderTaskProcessor( renderTaskProcessor ),
177 backgroundColor( Dali::DEFAULT_BACKGROUND_COLOR ),
181 panGestureProcessor( NULL ),
182 messageQueue( renderController, sceneGraphBuffers ),
183 frameCallbackProcessor( NULL ),
184 keepRenderingSeconds( 0.0f ),
185 nodeDirtyFlags( NodePropertyFlags::TRANSFORM ), // set to TransformFlag to ensure full update the first time through Update()
187 renderingBehavior( DevelStage::Rendering::IF_REQUIRED ),
188 animationFinishedDuringUpdate( false ),
189 previousUpdateScene( false ),
190 renderTaskWaiting( false ),
191 renderersAdded( false ),
192 surfaceRectChanged( false )
194 sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue );
196 // create first 'dummy' node
202 // Disconnect render tasks from nodes, before destroying the nodes
203 for( auto&& scene : scenes )
205 if ( scene && scene->taskList )
207 RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks();
208 for ( auto&& task : tasks )
210 task->SetSourceNode( NULL );
215 // UpdateManager owns the Nodes. Although Nodes are pool allocated they contain heap allocated parts
216 // like custom properties, which get released here
217 Vector<Node*>::Iterator iter = nodes.Begin()+1;
218 Vector<Node*>::Iterator endIter = nodes.End();
219 for(;iter!=endIter;++iter)
221 (*iter)->OnDestroy();
225 for( auto&& scene : scenes )
227 if ( scene && scene->root )
229 scene->root->OnDestroy();
230 Node::Delete( scene->root );
235 delete sceneController;
239 * Lazy init for FrameCallbackProcessor.
240 * @param[in] updateManager A reference to the update-manager
242 FrameCallbackProcessor& GetFrameCallbackProcessor( UpdateManager& updateManager )
244 if( ! frameCallbackProcessor )
246 frameCallbackProcessor = new FrameCallbackProcessor( updateManager, transformManager );
248 return *frameCallbackProcessor;
251 SceneGraphBuffers sceneGraphBuffers; ///< Used to keep track of which buffers are being written or read
252 RenderMessageDispatcher renderMessageDispatcher; ///< Used for passing messages to the render-thread
253 NotificationManager& notificationManager; ///< Queues notification messages for the event-thread.
254 TransformManager transformManager; ///< Used to update the transformation matrices of the nodes
255 CompleteNotificationInterface& animationPlaylist; ///< Holds handles to all the animations
256 PropertyNotifier& propertyNotifier; ///< Provides notification to applications when properties are modified.
257 ShaderSaver* shaderSaver; ///< Saves shader binaries.
258 DiscardQueue& discardQueue; ///< Nodes are added here when disconnected from the scene-graph.
259 RenderController& renderController; ///< render controller
260 SceneControllerImpl* sceneController; ///< scene controller
261 RenderManager& renderManager; ///< This is responsible for rendering the results of each "update"
262 RenderQueue& renderQueue; ///< Used to queue messages for the next render
263 RenderTaskProcessor& renderTaskProcessor; ///< Handles RenderTasks and RenderInstrucitons
265 Vector4 backgroundColor; ///< The glClear color used at the beginning of each frame.
267 using SceneInfoPtr = std::unique_ptr< SceneInfo >;
268 std::vector< SceneInfoPtr > scenes; ///< A container of SceneInfo.
270 Vector<Node*> nodes; ///< A container of all instantiated nodes
272 OwnerContainer< Camera* > cameras; ///< A container of cameras
273 OwnerContainer< PropertyOwner* > customObjects; ///< A container of owned objects (with custom properties)
275 OwnerContainer< PropertyResetterBase* > propertyResetters; ///< A container of property resetters
276 OwnerContainer< Animation* > animations; ///< A container of owned animations
277 PropertyNotificationContainer propertyNotifications; ///< A container of owner property notifications.
278 OwnerContainer< Renderer* > renderers; ///< A container of owned renderers
279 OwnerContainer< TextureSet* > textureSets; ///< A container of owned texture sets
280 OwnerContainer< Shader* > shaders; ///< A container of owned shaders
281 OwnerPointer< PanGesture > panGestureProcessor; ///< Owned pan gesture processor; it lives for the lifecycle of UpdateManager
283 MessageQueue messageQueue; ///< The messages queued from the event-thread
284 std::vector<Internal::ShaderDataPtr> renderCompiledShaders; ///< Shaders compiled on Render thread are inserted here for update thread to pass on to event thread.
285 std::vector<Internal::ShaderDataPtr> updateCompiledShaders; ///< Shaders to be sent from Update to Event
286 Mutex compiledShaderMutex; ///< lock to ensure no corruption on the renderCompiledShaders
288 OwnerPointer<FrameCallbackProcessor> frameCallbackProcessor; ///< Owned FrameCallbackProcessor, only created if required.
290 float keepRenderingSeconds; ///< Set via Dali::Stage::KeepRendering
291 NodePropertyFlags nodeDirtyFlags; ///< cumulative node dirty flags from previous frame
292 uint32_t frameCounter; ///< Frame counter used in debugging to choose which frame to debug and which to ignore.
294 DevelStage::Rendering renderingBehavior; ///< Set via DevelStage::SetRenderingBehavior
296 bool animationFinishedDuringUpdate; ///< Flag whether any animations finished during the Update()
297 bool previousUpdateScene; ///< True if the scene was updated in the previous frame (otherwise it was optimized out)
298 bool renderTaskWaiting; ///< A REFRESH_ONCE render task is waiting to be rendered
299 bool renderersAdded; ///< Flag to keep track when renderers have been added to avoid unnecessary processing
300 bool surfaceRectChanged; ///< True if the default surface rect is changed
304 Impl( const Impl& ); ///< Undefined
305 Impl& operator=( const Impl& ); ///< Undefined
308 UpdateManager::UpdateManager( NotificationManager& notificationManager,
309 CompleteNotificationInterface& animationFinishedNotifier,
310 PropertyNotifier& propertyNotifier,
311 DiscardQueue& discardQueue,
312 RenderController& controller,
313 RenderManager& renderManager,
314 RenderQueue& renderQueue,
315 RenderTaskProcessor& renderTaskProcessor )
318 mImpl = new Impl( notificationManager,
319 animationFinishedNotifier,
326 renderTaskProcessor );
330 UpdateManager::~UpdateManager()
335 void UpdateManager::InstallRoot( OwnerPointer<Layer>& layer )
337 DALI_ASSERT_DEBUG( layer->IsLayer() );
338 DALI_ASSERT_DEBUG( layer->GetParent() == NULL);
340 Layer* rootLayer = layer.Release();
342 DALI_ASSERT_DEBUG( std::find_if( mImpl->scenes.begin(), mImpl->scenes.end(),
343 [rootLayer]( Impl::SceneInfoPtr& scene )
345 return scene && scene->root == rootLayer;
347 ) == mImpl->scenes.end() && "Root Node already installed" );
349 rootLayer->CreateTransform( &mImpl->transformManager );
350 rootLayer->SetRoot(true);
352 mImpl->scenes.emplace_back( new Impl::SceneInfo( rootLayer ) );
355 void UpdateManager::UninstallRoot( Layer* layer )
357 DALI_ASSERT_DEBUG( layer->IsLayer() );
358 DALI_ASSERT_DEBUG( layer->GetParent() == NULL );
360 for (auto iter = mImpl->scenes.begin(); iter != mImpl->scenes.end(); ++iter)
362 if( (*iter) && (*iter)->root == layer )
364 mImpl->scenes.erase( iter );
369 mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), layer );
371 // Notify the layer about impending destruction
375 void UpdateManager::AddNode( OwnerPointer<Node>& node )
377 DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
379 // Nodes must be sorted by pointer
380 Node* rawNode = node.Release();
381 DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] AddNode\n", rawNode );
383 Vector<Node*>::Iterator begin = mImpl->nodes.Begin();
384 for( Vector<Node*>::Iterator iter = mImpl->nodes.End()-1; iter >= begin; --iter )
386 if( rawNode > (*iter) )
388 mImpl->nodes.Insert((iter+1), rawNode );
389 rawNode->CreateTransform( &mImpl->transformManager );
395 void UpdateManager::ConnectNode( Node* parent, Node* node )
397 DALI_ASSERT_ALWAYS( NULL != parent );
398 DALI_ASSERT_ALWAYS( NULL != node );
399 DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
401 DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] ConnectNode\n", node );
403 parent->ConnectChild( node );
405 // Inform the frame-callback-processor, if set, about the node-hierarchy changing
406 if( mImpl->frameCallbackProcessor )
408 mImpl->frameCallbackProcessor->NodeHierarchyChanged();
412 void UpdateManager::DisconnectNode( Node* node )
414 DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] DisconnectNode\n", node );
416 Node* parent = node->GetParent();
417 DALI_ASSERT_ALWAYS( NULL != parent );
418 parent->SetDirtyFlag( NodePropertyFlags::CHILD_DELETED ); // make parent dirty so that render items dont get reused
420 parent->DisconnectChild( mSceneGraphBuffers.GetUpdateBufferIndex(), *node );
422 // Inform the frame-callback-processor, if set, about the node-hierarchy changing
423 if( mImpl->frameCallbackProcessor )
425 mImpl->frameCallbackProcessor->NodeHierarchyChanged();
429 void UpdateManager::DestroyNode( Node* node )
431 DALI_ASSERT_ALWAYS( NULL != node );
432 DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should have been disconnected
434 DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] DestroyNode\n", node );
436 Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
437 Vector<Node*>::Iterator endIter = mImpl->nodes.End();
438 for(;iter!=endIter;++iter)
442 mImpl->nodes.Erase(iter);
447 mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), node );
449 // Notify the Node about impending destruction
453 void UpdateManager::AddCamera( OwnerPointer< Camera >& camera )
455 mImpl->cameras.PushBack( camera.Release() ); // takes ownership
458 void UpdateManager::RemoveCamera( Camera* camera )
460 // Find the camera and destroy it
461 EraseUsingDiscardQueue( mImpl->cameras, camera, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
464 void UpdateManager::AddObject( OwnerPointer<PropertyOwner>& object )
466 mImpl->customObjects.PushBack( object.Release() );
469 void UpdateManager::RemoveObject( PropertyOwner* object )
471 mImpl->customObjects.EraseObject( object );
474 void UpdateManager::AddRenderTaskList( OwnerPointer<RenderTaskList>& taskList )
476 RenderTaskList* taskListPointer = taskList.Release();
477 taskListPointer->SetRenderMessageDispatcher( &mImpl->renderMessageDispatcher );
479 mImpl->scenes.back()->taskList = taskListPointer;
482 void UpdateManager::RemoveRenderTaskList( RenderTaskList* taskList )
484 for ( auto&& scene : mImpl->scenes )
486 if ( scene && scene->taskList == taskList )
488 scene->taskList.Reset();
494 void UpdateManager::AddScene( OwnerPointer< Scene >& scene )
496 mImpl->scenes.back()->scene = scene.Release();
498 // Initialize the context from render manager
499 typedef MessageValue1< RenderManager, SceneGraph::Scene* > DerivedType;
501 // Reserve some memory inside the render queue
502 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
504 // Construct message in the render queue memory; note that delete should not be called on the return value
505 SceneGraph::Scene& sceneObject = *mImpl->scenes.back()->scene;
506 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::InitializeScene, &sceneObject );
509 void UpdateManager::RemoveScene( Scene* scene )
511 // Initialize the context from render manager
512 using DerivedType = MessageValue1<RenderManager, SceneGraph::Scene*>;
514 // Reserve some memory inside the render queue
515 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
517 // Construct message in the render queue memory; note that delete should not be called on the return value
518 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UninitializeScene, scene );
520 for ( auto&& sceneInfo : mImpl->scenes )
522 if ( sceneInfo && sceneInfo->scene && sceneInfo->scene.Get() == scene )
524 mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), sceneInfo->scene.Release() ); // take the address of the reference to a pointer
530 void UpdateManager::AddAnimation( OwnerPointer< SceneGraph::Animation >& animation )
532 mImpl->animations.PushBack( animation.Release() );
535 void UpdateManager::StopAnimation( Animation* animation )
537 DALI_ASSERT_DEBUG( animation && "NULL animation called to stop" );
539 bool animationFinished = animation->Stop( mSceneGraphBuffers.GetUpdateBufferIndex() );
541 mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || animationFinished;
544 void UpdateManager::RemoveAnimation( Animation* animation )
546 DALI_ASSERT_DEBUG( animation && "NULL animation called to remove" );
548 animation->OnDestroy( mSceneGraphBuffers.GetUpdateBufferIndex() );
550 DALI_ASSERT_DEBUG( animation->GetState() == Animation::Destroyed );
553 bool UpdateManager::IsAnimationRunning() const
555 // Find any animation that isn't stopped or paused
556 for ( auto&& iter : mImpl->animations )
558 const Animation::State state = iter->GetState();
560 if (state != Animation::Stopped &&
561 state != Animation::Paused)
563 return true; // stop iteration as soon as first one is found
570 void UpdateManager::AddPropertyResetter( OwnerPointer<PropertyResetterBase>& propertyResetter )
572 propertyResetter->Initialize();
573 mImpl->propertyResetters.PushBack( propertyResetter.Release() );
576 void UpdateManager::AddPropertyNotification( OwnerPointer< PropertyNotification >& propertyNotification )
578 mImpl->propertyNotifications.PushBack( propertyNotification.Release() );
581 void UpdateManager::RemovePropertyNotification( PropertyNotification* propertyNotification )
583 mImpl->propertyNotifications.EraseObject( propertyNotification );
586 void UpdateManager::PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode )
588 DALI_ASSERT_DEBUG( propertyNotification && "propertyNotification scene graph object missing" );
589 propertyNotification->SetNotifyMode( notifyMode );
592 void UpdateManager::AddShader( OwnerPointer< Shader >& shader )
594 mImpl->shaders.PushBack( shader.Release() );
597 void UpdateManager::RemoveShader( Shader* shader )
599 // Find the shader and destroy it
600 EraseUsingDiscardQueue( mImpl->shaders, shader, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
603 void UpdateManager::SetShaderProgram( Shader* shader,
604 Internal::ShaderDataPtr shaderData, bool modifiesGeometry )
608 using DerivedType = MessageValue3<Shader, Internal::ShaderDataPtr, ProgramCache*, bool>;
610 // Reserve some memory inside the render queue
611 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
613 // Construct message in the render queue memory; note that delete should not be called on the return value
614 new (slot) DerivedType( shader, &Shader::SetProgram, shaderData, mImpl->renderManager.GetProgramCache(), modifiesGeometry );
618 void UpdateManager::SaveBinary( Internal::ShaderDataPtr shaderData )
620 DALI_ASSERT_DEBUG( shaderData && "No NULL shader data pointers please." );
621 DALI_ASSERT_DEBUG( shaderData->GetBufferSize() > 0 && "Shader binary empty so nothing to save." );
623 // lock as update might be sending previously compiled shaders to event thread
624 Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
625 mImpl->renderCompiledShaders.push_back( shaderData );
629 void UpdateManager::SetShaderSaver( ShaderSaver& upstream )
631 mImpl->shaderSaver = &upstream;
634 void UpdateManager::AddRenderer( OwnerPointer< Renderer >& renderer )
636 DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] AddRenderer\n", renderer.Get() );
638 renderer->ConnectToSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() );
639 mImpl->renderers.PushBack( renderer.Release() );
640 mImpl->renderersAdded = true;
643 void UpdateManager::RemoveRenderer( Renderer* renderer )
645 DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] RemoveRenderer\n", renderer );
647 // Find the renderer and destroy it
648 EraseUsingDiscardQueue( mImpl->renderers, renderer, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
649 // Need to remove the render object as well
650 renderer->DisconnectFromSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() );
653 void UpdateManager::SetPanGestureProcessor( PanGesture* panGestureProcessor )
655 DALI_ASSERT_DEBUG( NULL != panGestureProcessor );
657 mImpl->panGestureProcessor = panGestureProcessor;
660 void UpdateManager::AddTextureSet( OwnerPointer< TextureSet >& textureSet )
662 mImpl->textureSets.PushBack( textureSet.Release() );
665 void UpdateManager::RemoveTextureSet( TextureSet* textureSet )
667 mImpl->textureSets.EraseObject( textureSet );
670 uint32_t* UpdateManager::ReserveMessageSlot( uint32_t size, bool updateScene )
672 return mImpl->messageQueue.ReserveMessageSlot( size, updateScene );
675 void UpdateManager::EventProcessingStarted()
677 mImpl->messageQueue.EventProcessingStarted();
680 bool UpdateManager::FlushQueue()
682 return mImpl->messageQueue.FlushQueue();
685 void UpdateManager::ResetProperties( BufferIndex bufferIndex )
687 // Clear the "animations finished" flag; This should be set if any (previously playing) animation is stopped
688 mImpl->animationFinishedDuringUpdate = false;
690 // Reset all animating / constrained properties
691 std::vector<PropertyResetterBase*>toDelete;
692 for( auto&& element : mImpl->propertyResetters )
694 element->ResetToBaseValue( bufferIndex );
695 if( element->IsFinished() )
697 toDelete.push_back( element );
701 // If a resetter is no longer required (the animator or constraint has been removed), delete it.
702 for( auto&& elementPtr : toDelete )
704 mImpl->propertyResetters.EraseObject( elementPtr );
707 // Clear all root nodes dirty flags
708 for( auto& scene : mImpl->scenes )
710 auto root = scene->root;
711 root->ResetDirtyFlags( bufferIndex );
714 // Clear node dirty flags
715 Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
716 Vector<Node*>::Iterator endIter = mImpl->nodes.End();
717 for( ;iter != endIter; ++iter )
719 (*iter)->ResetDirtyFlags( bufferIndex );
723 bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, uint32_t lastVSyncTimeMilliseconds, uint32_t nextVSyncTimeMilliseconds )
725 bool gestureUpdated( false );
727 if( mImpl->panGestureProcessor )
729 // gesture processor only supports default properties
730 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
731 gestureUpdated |= mImpl->panGestureProcessor->UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
734 return gestureUpdated;
737 void UpdateManager::Animate( BufferIndex bufferIndex, float elapsedSeconds )
739 auto&& iter = mImpl->animations.Begin();
740 bool animationLooped = false;
742 while ( iter != mImpl->animations.End() )
744 Animation* animation = *iter;
745 bool finished = false;
747 bool progressMarkerReached = false;
748 animation->Update( bufferIndex, elapsedSeconds, looped, finished, progressMarkerReached );
750 if ( progressMarkerReached )
752 mImpl->notificationManager.QueueMessage( Internal::NotifyProgressReachedMessage( mImpl->animationPlaylist, animation ) );
755 mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || finished;
756 animationLooped = animationLooped || looped;
758 // Remove animations that had been destroyed but were still waiting for an update
759 if (animation->GetState() == Animation::Destroyed)
761 iter = mImpl->animations.Erase(iter);
769 // queue the notification on finished or looped (to update loop count)
770 if ( mImpl->animationFinishedDuringUpdate || animationLooped )
772 // The application should be notified by NotificationManager, in another thread
773 mImpl->notificationManager.QueueCompleteNotification( &mImpl->animationPlaylist );
777 void UpdateManager::ConstrainCustomObjects( BufferIndex bufferIndex )
779 //Constrain custom objects (in construction order)
780 for ( auto&& object : mImpl->customObjects )
782 ConstrainPropertyOwner( *object, bufferIndex );
786 void UpdateManager::ConstrainRenderTasks( BufferIndex bufferIndex )
788 // Constrain render-tasks
789 for ( auto&& scene : mImpl->scenes )
791 if ( scene && scene->taskList )
793 RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks();
794 for ( auto&& task : tasks )
796 ConstrainPropertyOwner( *task, bufferIndex );
802 void UpdateManager::ConstrainShaders( BufferIndex bufferIndex )
804 // constrain shaders... (in construction order)
805 for ( auto&& shader : mImpl->shaders )
807 ConstrainPropertyOwner( *shader, bufferIndex );
811 void UpdateManager::ProcessPropertyNotifications( BufferIndex bufferIndex )
813 for( auto&& notification : mImpl->propertyNotifications )
815 bool valid = notification->Check( bufferIndex );
818 mImpl->notificationManager.QueueMessage( PropertyChangedMessage( mImpl->propertyNotifier, notification, notification->GetValidity() ) );
823 void UpdateManager::ForwardCompiledShadersToEventThread()
825 DALI_ASSERT_DEBUG( (mImpl->shaderSaver != 0) && "shaderSaver should be wired-up during startup." );
826 if( mImpl->shaderSaver )
828 // lock and swap the queues
830 // render might be attempting to send us more binaries at the same time
831 Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
832 mImpl->renderCompiledShaders.swap( mImpl->updateCompiledShaders );
835 if( mImpl->updateCompiledShaders.size() > 0 )
837 ShaderSaver& factory = *mImpl->shaderSaver;
838 for( auto&& shader : mImpl->updateCompiledShaders )
840 mImpl->notificationManager.QueueMessage( ShaderCompiledMessage( factory, shader ) );
842 // we don't need them in update anymore
843 mImpl->updateCompiledShaders.clear();
848 void UpdateManager::UpdateRenderers( BufferIndex bufferIndex )
850 for( auto&& renderer : mImpl->renderers )
853 ConstrainPropertyOwner( *renderer, bufferIndex );
855 renderer->PrepareRender( bufferIndex );
859 void UpdateManager::UpdateNodes( BufferIndex bufferIndex )
861 mImpl->nodeDirtyFlags = NodePropertyFlags::NOTHING;
863 for ( auto&& scene : mImpl->scenes )
865 if ( scene && scene->root )
867 // Prepare resources, update shaders, for each node
868 // And add the renderers to the sorted layers. Start from root, which is also a layer
869 mImpl->nodeDirtyFlags |= UpdateNodeTree( *scene->root,
871 mImpl->renderQueue );
876 uint32_t UpdateManager::Update( float elapsedSeconds,
877 uint32_t lastVSyncTimeMilliseconds,
878 uint32_t nextVSyncTimeMilliseconds,
879 bool renderToFboEnabled,
880 bool isRenderingToFbo )
882 const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
884 //Clear nodes/resources which were previously discarded
885 mImpl->discardQueue.Clear( bufferIndex );
887 //Process Touches & Gestures
888 const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
890 bool updateScene = // The scene-graph requires an update if..
891 (mImpl->nodeDirtyFlags & RenderableUpdateFlags) || // ..nodes were dirty in previous frame OR
892 IsAnimationRunning() || // ..at least one animation is running OR
893 mImpl->messageQueue.IsSceneUpdateRequired() || // ..a message that modifies the scene graph node tree is queued OR
894 gestureUpdated; // ..a gesture property was updated
896 bool keepRendererRendering = false;
898 // Although the scene-graph may not require an update, we still need to synchronize double-buffered
899 // values if the scene was updated in the previous frame.
900 if( updateScene || mImpl->previousUpdateScene )
902 //Reset properties from the previous update
903 ResetProperties( bufferIndex );
904 mImpl->transformManager.ResetToBaseValue();
907 // Process the queued scene messages. Note, MessageQueue::FlushQueue may be called
908 // between calling IsSceneUpdateRequired() above and here, so updateScene should
910 updateScene |= mImpl->messageQueue.ProcessMessages( bufferIndex );
912 //Forward compiled shader programs to event thread for saving
913 ForwardCompiledShadersToEventThread();
915 // Although the scene-graph may not require an update, we still need to synchronize double-buffered
916 // renderer lists if the scene was updated in the previous frame.
917 // We should not start skipping update steps or reusing lists until there has been two frames where nothing changes
918 if( updateScene || mImpl->previousUpdateScene )
921 Animate( bufferIndex, elapsedSeconds );
923 //Constraint custom objects
924 ConstrainCustomObjects( bufferIndex );
926 //Clear the lists of renderers from the previous update
927 for( auto&& scene : mImpl->scenes )
931 for( auto&& layer : scene->sortedLayerList )
935 layer->ClearRenderables();
941 // Call the frame-callback-processor if set
942 if( mImpl->frameCallbackProcessor )
944 mImpl->frameCallbackProcessor->Update( bufferIndex, elapsedSeconds );
947 //Update node hierarchy, apply constraints and perform sorting / culling.
948 //This will populate each Layer with a list of renderers which are ready.
949 UpdateNodes( bufferIndex );
951 //Apply constraints to RenderTasks, shaders
952 ConstrainRenderTasks( bufferIndex );
953 ConstrainShaders( bufferIndex );
955 //Update renderers and apply constraints
956 UpdateRenderers( bufferIndex );
958 //Update the transformations of all the nodes
959 mImpl->transformManager.Update();
961 //Process Property Notifications
962 ProcessPropertyNotifications( bufferIndex );
965 for( auto&& cameraIterator : mImpl->cameras )
967 cameraIterator->Update( bufferIndex );
970 //Process the RenderTasks if renderers exist. This creates the instructions for rendering the next frame.
971 //reset the update buffer index and make sure there is enough room in the instruction container
972 if( mImpl->renderersAdded )
974 // Calculate how many render tasks we have in total
975 std::size_t numberOfRenderTasks = 0;
976 for (auto&& scene : mImpl->scenes )
978 if ( scene && scene->taskList )
980 numberOfRenderTasks += scene->taskList->GetTasks().Count();
985 std::size_t numberOfRenderInstructions = 0;
986 for ( auto&& scene : mImpl->scenes )
988 if ( scene && scene->root && scene->taskList && scene->scene )
990 scene->scene->GetRenderInstructions().ResetAndReserve( bufferIndex,
991 static_cast<uint32_t>( scene->taskList->GetTasks().Count() ) );
993 keepRendererRendering |= mImpl->renderTaskProcessor.Process( bufferIndex,
996 scene->sortedLayerList,
997 scene->scene->GetRenderInstructions(),
1001 numberOfRenderInstructions += scene->scene->GetRenderInstructions().Count( bufferIndex );
1005 DALI_LOG_INFO( gLogFilter, Debug::General,
1006 "Update: numberOfRenderTasks(%d), Render Instructions(%d)\n",
1007 numberOfRenderTasks, numberOfRenderInstructions );
1011 for ( auto&& scene : mImpl->scenes )
1013 if ( scene && scene->root && scene->taskList )
1015 RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks();
1017 // check the countdown and notify
1018 bool doRenderOnceNotify = false;
1019 mImpl->renderTaskWaiting = false;
1020 for ( auto&& renderTask : tasks )
1022 renderTask->UpdateState();
1024 if( renderTask->IsWaitingToRender() &&
1025 renderTask->ReadyToRender( bufferIndex ) /*avoid updating forever when source actor is off-stage*/ )
1027 mImpl->renderTaskWaiting = true; // keep update/render threads alive
1030 if( renderTask->HasRendered() )
1032 doRenderOnceNotify = true;
1036 if( doRenderOnceNotify )
1038 DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n");
1039 mImpl->notificationManager.QueueCompleteNotification( scene->taskList->GetCompleteNotificationInterface() );
1044 // Macro is undefined in release build.
1045 SNAPSHOT_NODE_LOGGING;
1047 // A ResetProperties() may be required in the next frame
1048 mImpl->previousUpdateScene = updateScene;
1050 // Check whether further updates are required
1051 uint32_t keepUpdating = KeepUpdatingCheck( elapsedSeconds );
1053 if( keepRendererRendering )
1055 keepUpdating |= KeepUpdating::STAGE_KEEP_RENDERING;
1057 // Set dirty flags for next frame to continue rendering
1058 mImpl->nodeDirtyFlags |= RenderableUpdateFlags;
1061 // tell the update manager that we're done so the queue can be given to event thread
1062 mImpl->notificationManager.UpdateCompleted();
1064 // The update has finished; swap the double-buffering indices
1065 mSceneGraphBuffers.Swap();
1067 return keepUpdating;
1070 uint32_t UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const
1072 // Update the duration set via Stage::KeepRendering()
1073 if ( mImpl->keepRenderingSeconds > 0.0f )
1075 mImpl->keepRenderingSeconds -= elapsedSeconds;
1078 uint32_t keepUpdatingRequest = KeepUpdating::NOT_REQUESTED;
1080 // If the rendering behavior is set to continuously render, then continue to render.
1081 // If Stage::KeepRendering() has been called, then continue until the duration has elapsed.
1082 // Keep updating until no messages are received and no animations are running.
1083 // If an animation has just finished, update at least once more for Discard end-actions.
1084 // No need to check for renderQueue as there is always a render after update and if that
1085 // render needs another update it will tell the adaptor to call update again
1087 if ( ( mImpl->renderingBehavior == DevelStage::Rendering::CONTINUOUSLY ) ||
1088 ( mImpl->keepRenderingSeconds > 0.0f ) )
1090 keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING;
1093 if ( IsAnimationRunning() ||
1094 mImpl->animationFinishedDuringUpdate )
1096 keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING;
1099 if ( mImpl->renderTaskWaiting )
1101 keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC;
1104 return keepUpdatingRequest;
1107 void UpdateManager::SetDefaultSurfaceRect( const Rect<int32_t>& rect )
1109 mImpl->surfaceRectChanged = true;
1111 using DerivedType = MessageValue1<RenderManager, Rect<int32_t> >;
1113 // Reserve some memory inside the render queue
1114 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1116 // Construct message in the render queue memory; note that delete should not be called on the return value
1117 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetDefaultSurfaceRect, rect );
1120 void UpdateManager::SurfaceReplaced( Scene* scene )
1122 using DerivedType = MessageValue1<RenderManager, Scene*>;
1124 // Reserve some memory inside the render queue
1125 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1127 // Construct message in the render queue memory; note that delete should not be called on the return value
1128 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SurfaceReplaced, scene );
1131 void UpdateManager::KeepRendering( float durationSeconds )
1133 mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds );
1136 void UpdateManager::SetRenderingBehavior( DevelStage::Rendering renderingBehavior )
1138 mImpl->renderingBehavior = renderingBehavior;
1141 void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, const Layer* rootLayer )
1143 for ( auto&& scene : mImpl->scenes )
1145 if ( scene && scene->root == rootLayer )
1147 scene->sortedLayerList = layers;
1153 void UpdateManager::SetDepthIndices( OwnerPointer< NodeDepths >& nodeDepths )
1155 // note,this vector is already in depth order. It could be used as-is to
1156 // remove sorting in update algorithm. However, it lacks layer boundary markers.
1157 for( auto&& iter : nodeDepths->nodeDepths )
1159 iter.node->SetDepthIndex( iter.sortedDepth );
1162 for ( auto&& scene : mImpl->scenes )
1166 // Go through node hierarchy and rearrange siblings according to depth-index
1167 SortSiblingNodesRecursively( *scene->root );
1172 bool UpdateManager::IsDefaultSurfaceRectChanged()
1174 bool surfaceRectChanged = mImpl->surfaceRectChanged;
1177 mImpl->surfaceRectChanged = false;
1179 return surfaceRectChanged;
1182 void UpdateManager::AddFrameCallback( OwnerPointer< FrameCallback >& frameCallback, const Node* rootNode )
1184 mImpl->GetFrameCallbackProcessor( *this ).AddFrameCallback( frameCallback, rootNode );
1187 void UpdateManager::RemoveFrameCallback( FrameCallbackInterface* frameCallback )
1189 mImpl->GetFrameCallbackProcessor( *this ).RemoveFrameCallback( frameCallback );
1192 void UpdateManager::AddSampler( OwnerPointer< Render::Sampler >& sampler )
1194 // Message has ownership of Sampler while in transit from update to render
1195 using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::Sampler> >;
1197 // Reserve some memory inside the render queue
1198 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1200 // Construct message in the render queue memory; note that delete should not be called on the return value
1201 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddSampler, sampler );
1204 void UpdateManager::RemoveSampler( Render::Sampler* sampler )
1206 using DerivedType = MessageValue1<RenderManager, Render::Sampler*>;
1208 // Reserve some memory inside the render queue
1209 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1211 // Construct message in the render queue memory; note that delete should not be called on the return value
1212 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveSampler, sampler );
1215 void UpdateManager::SetFilterMode( Render::Sampler* sampler, uint32_t minFilterMode, uint32_t magFilterMode )
1217 using DerivedType = MessageValue3<RenderManager, Render::Sampler*, uint32_t, uint32_t>;
1219 // Reserve some memory inside the render queue
1220 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1222 // Construct message in the render queue memory; note that delete should not be called on the return value
1223 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
1226 void UpdateManager::SetWrapMode( Render::Sampler* sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode )
1228 using DerivedType = MessageValue4<RenderManager, Render::Sampler*, uint32_t, uint32_t, uint32_t>;
1230 // Reserve some memory inside the render queue
1231 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1233 // Construct message in the render queue memory; note that delete should not be called on the return value
1234 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode );
1237 void UpdateManager::AddVertexBuffer( OwnerPointer< Render::VertexBuffer >& vertexBuffer )
1239 // Message has ownership of format while in transit from update -> render
1240 using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::VertexBuffer> >;
1242 // Reserve some memory inside the render queue
1243 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1245 // Construct message in the render queue memory; note that delete should not be called on the return value
1246 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddVertexBuffer, vertexBuffer );
1249 void UpdateManager::RemoveVertexBuffer( Render::VertexBuffer* vertexBuffer )
1251 using DerivedType = MessageValue1<RenderManager, Render::VertexBuffer*>;
1253 // Reserve some memory inside the render queue
1254 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1256 // Construct message in the render queue memory; note that delete should not be called on the return value
1257 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveVertexBuffer, vertexBuffer );
1260 void UpdateManager::SetVertexBufferFormat( Render::VertexBuffer* vertexBuffer, OwnerPointer< Render::VertexBuffer::Format>& format )
1262 // Message has ownership of format while in transit from update -> render
1263 using DerivedType = MessageValue2<RenderManager, Render::VertexBuffer*, OwnerPointer<Render::VertexBuffer::Format> >;
1265 // Reserve some memory inside the render queue
1266 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1268 // Construct message in the render queue memory; note that delete should not be called on the return value
1269 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetVertexBufferFormat, vertexBuffer, format );
1272 void UpdateManager::SetVertexBufferData( Render::VertexBuffer* vertexBuffer, OwnerPointer< Vector<uint8_t> >& data, uint32_t size )
1274 // Message has ownership of format while in transit from update -> render
1275 using DerivedType = MessageValue3<RenderManager, Render::VertexBuffer*, OwnerPointer<Dali::Vector<uint8_t> >, uint32_t>;
1277 // Reserve some memory inside the render queue
1278 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1280 // Construct message in the render queue memory; note that delete should not be called on the return value
1281 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetVertexBufferData, vertexBuffer, data, size );
1284 void UpdateManager::AddGeometry( OwnerPointer< Render::Geometry >& geometry )
1286 // Message has ownership of format while in transit from update -> render
1287 using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::Geometry> >;
1289 // Reserve some memory inside the render queue
1290 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1292 // Construct message in the render queue memory; note that delete should not be called on the return value
1293 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddGeometry, geometry );
1296 void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
1298 using DerivedType = MessageValue1<RenderManager, Render::Geometry*>;
1300 // Reserve some memory inside the render queue
1301 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1303 // Construct message in the render queue memory; note that delete should not be called on the return value
1304 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveGeometry, geometry );
1307 void UpdateManager::SetGeometryType( Render::Geometry* geometry, uint32_t geometryType )
1309 using DerivedType = MessageValue2<RenderManager, Render::Geometry*, uint32_t>;
1311 // Reserve some memory inside the render queue
1312 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1314 // Construct message in the render queue memory; note that delete should not be called on the return value
1315 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetGeometryType, geometry, geometryType );
1318 void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<uint16_t>& indices )
1320 using DerivedType = IndexBufferMessage<RenderManager>;
1322 // Reserve some memory inside the render queue
1323 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1325 // Construct message in the render queue memory; note that delete should not be called on the return value
1326 new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
1329 void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer )
1331 using DerivedType = MessageValue2<RenderManager, Render::Geometry*, Render::VertexBuffer*>;
1333 // Reserve some memory inside the render queue
1334 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1336 // Construct message in the render queue memory; note that delete should not be called on the return value
1337 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveVertexBuffer, geometry, vertexBuffer );
1340 void UpdateManager::AttachVertexBuffer( Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer )
1342 using DerivedType = MessageValue2<RenderManager, Render::Geometry*, Render::VertexBuffer*>;
1344 // Reserve some memory inside the render queue
1345 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1347 // Construct message in the render queue memory; note that delete should not be called on the return value
1348 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AttachVertexBuffer, geometry, vertexBuffer );
1351 void UpdateManager::AddTexture( OwnerPointer< Render::Texture >& texture )
1353 // Message has ownership of Texture while in transit from update -> render
1354 using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::Texture> >;
1356 // Reserve some memory inside the render queue
1357 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1359 // Construct message in the render queue memory; note that delete should not be called on the return value
1360 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddTexture, texture );
1363 void UpdateManager::RemoveTexture( Render::Texture* texture)
1365 using DerivedType = MessageValue1<RenderManager, Render::Texture*>;
1367 // Reserve some memory inside the render queue
1368 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1370 // Construct message in the render queue memory; note that delete should not be called on the return value
1371 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveTexture, texture );
1374 void UpdateManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
1376 using DerivedType = MessageValue3<RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams>;
1378 // Reserve some memory inside the message queue
1379 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1381 // Construct message in the message queue memory; note that delete should not be called on the return value
1382 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params );
1385 void UpdateManager::GenerateMipmaps( Render::Texture* texture )
1387 using DerivedType = MessageValue1<RenderManager, Render::Texture*>;
1389 // Reserve some memory inside the render queue
1390 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1392 // Construct message in the render queue memory; note that delete should not be called on the return value
1393 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::GenerateMipmaps, texture );
1396 void UpdateManager::AddFrameBuffer( OwnerPointer< Render::FrameBuffer >& frameBuffer )
1398 using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::FrameBuffer> >;
1400 // Reserve some memory inside the render queue
1401 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1403 // Construct message in the render queue memory; note that delete should not be called on the return value
1404 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddFrameBuffer, frameBuffer );
1407 void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
1409 using DerivedType = MessageValue1<RenderManager, Render::FrameBuffer*>;
1411 // Reserve some memory inside the render queue
1412 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1414 // Construct message in the render queue memory; note that delete should not be called on the return value
1415 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveFrameBuffer, frameBuffer );
1418 void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
1420 using DerivedType = MessageValue4<RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t>;
1422 // Reserve some memory inside the render queue
1423 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1425 // Construct message in the render queue memory; note that delete should not be called on the return value
1426 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer );
1429 void UpdateManager::AttachDepthTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
1431 using DerivedType = MessageValue3<RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t>;
1433 // Reserve some memory inside the render queue
1434 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1436 // Construct message in the render queue memory; note that delete should not be called on the return value
1437 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AttachDepthTextureToFrameBuffer, frameBuffer, texture, mipmapLevel );
1440 void UpdateManager::AttachDepthStencilTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
1442 using DerivedType = MessageValue3<RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t>;
1444 // Reserve some memory inside the render queue
1445 uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1447 // Construct message in the render queue memory; note that delete should not be called on the return value
1448 new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AttachDepthStencilTextureToFrameBuffer, frameBuffer, texture, mipmapLevel );
1451 } // namespace SceneGraph
1453 } // namespace Internal