X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fmanager%2Fupdate-manager.cpp;h=879707b5a0985c5201c8be100438ded6686c52e3;hb=f6857330bd12f29b793ed22dc5ca82ec898a1280;hp=b0a37875a4e61aa16cfeee9df2e9bf59f074dd6e;hpb=019bc7f9921d519bb666bc465ae424f028751770;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/manager/update-manager.cpp b/dali/internal/update/manager/update-manager.cpp index b0a3787..879707b 100644 --- a/dali/internal/update/manager/update-manager.cpp +++ b/dali/internal/update/manager/update-manager.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,19 +21,19 @@ // INTERNAL INCLUDES #include +#include #include #include #include -#include #include #include #include #include #include +#include #include #include -#include #include #include @@ -43,21 +43,21 @@ // Un-comment to enable node tree debug logging //#define NODE_TREE_LOGGING 1 -#if ( defined( DEBUG_ENABLED ) && defined( NODE_TREE_LOGGING ) ) -#define SNAPSHOT_NODE_LOGGING \ -const uint32_t FRAME_COUNT_TRIGGER = 16;\ -if( mImpl->frameCounter >= FRAME_COUNT_TRIGGER )\ - {\ - for( auto&& scene : mImpl->scenes ) - {\ - if ( scene && scene->root )\ - {\ - mImpl->frameCounter = 0;\ - PrintNodeTree( *scene->root, mSceneGraphBuffers.GetUpdateBufferIndex(), "" );\ - }\ - }\ - }\ -mImpl->frameCounter++; +#if(defined(DEBUG_ENABLED) && defined(NODE_TREE_LOGGING)) +#define SNAPSHOT_NODE_LOGGING \ + const uint32_t FRAME_COUNT_TRIGGER = 16; \ + if(mImpl->frameCounter >= FRAME_COUNT_TRIGGER) \ + { \ + for(auto&& scene : mImpl->scenes) \ + { \ + if(scene && scene->root) \ + { \ + mImpl->frameCounter = 0; \ + PrintNodes(*scene->root, mSceneGraphBuffers.GetUpdateBufferIndex(), 0); \ + } \ + } \ + } \ + mImpl->frameCounter++; #else #define SNAPSHOT_NODE_LOGGING #endif @@ -66,23 +66,19 @@ mImpl->frameCounter++; extern Debug::Filter* gRenderTaskLogFilter; namespace { -Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_UPDATE_MANAGER" ); +Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_UPDATE_MANAGER"); } // unnamed namespace #endif - using namespace Dali::Integration; using Dali::Internal::Update::MessageQueue; namespace Dali { - namespace Internal { - namespace SceneGraph { - namespace { /** @@ -92,19 +88,19 @@ namespace * @param discardQueue to put the object to * @param updateBufferIndex to use */ -template < class T > -inline void EraseUsingDiscardQueue( OwnerContainer& container, T* object, DiscardQueue& discardQueue, BufferIndex updateBufferIndex ) +template +inline void EraseUsingDiscardQueue(OwnerContainer& container, T* object, DiscardQueue& discardQueue, BufferIndex updateBufferIndex) { - DALI_ASSERT_DEBUG( object && "NULL object not allowed" ); + DALI_ASSERT_DEBUG(object && "NULL object not allowed"); // need to use the reference version of auto as we need the pointer to the pointer for the Release call below - for( auto&& iter : container ) + for(auto&& iter : container) { - if ( iter == object ) + if(iter == object) { // Transfer ownership to the discard queue, this keeps the object alive, until the render-thread has finished with it - discardQueue.Add( updateBufferIndex, container.Release( &iter ) ); // take the address of the reference to a pointer (iter) - return; // return as we only ever remove one object. Iterators to container are now invalidated as well so cannot continue + discardQueue.Add(updateBufferIndex, container.Release(&iter)); // take the address of the reference to a pointer (iter) + return; // return as we only ever remove one object. Iterators to container are now invalidated as well so cannot continue } } } @@ -113,16 +109,15 @@ inline void EraseUsingDiscardQueue( OwnerContainer& container, T* object, Di * Descends into node's hierarchy and sorts the children of each child according to their depth-index. * @param[in] node The node whose hierarchy to descend */ -void SortSiblingNodesRecursively( Node& node ) +void SortSiblingNodesRecursively(Node& node) { NodeContainer& container = node.GetChildren(); - std::sort( container.Begin(), container.End(), - []( Node* a, Node* b ) { return a->GetDepthIndex() < b->GetDepthIndex(); } ); + std::sort(container.Begin(), container.End(), [](Node* a, Node* b) { return a->GetDepthIndex() < b->GetDepthIndex(); }); // Descend tree and sort as well - for( auto&& iter : container ) + for(auto&& iter : container) { - SortSiblingNodesRecursively( *iter ); + SortSiblingNodesRecursively(*iter); } } @@ -136,195 +131,198 @@ struct UpdateManager::Impl // SceneInfo keeps the root node of the Scene, its scene graph render task list, and the list of Layer pointers sorted by depth struct SceneInfo { - SceneInfo( Layer* root ) ///< Constructor - : root( root ) + SceneInfo(Layer* root) ///< Constructor + : root(root) { } - ~SceneInfo() = default; ///< Default non-virtual destructor - SceneInfo( SceneInfo&& rhs ) = default; ///< Move constructor - SceneInfo& operator=( SceneInfo&& rhs ) = default; ///< Move assignment operator - SceneInfo& operator=( const SceneInfo& rhs ) = delete; ///< Assignment operator - SceneInfo( const SceneInfo& rhs ) = delete; ///< Copy constructor + ~SceneInfo() = default; ///< Default non-virtual destructor + SceneInfo(SceneInfo&& rhs) = default; ///< Move constructor + SceneInfo& operator=(SceneInfo&& rhs) = default; ///< Move assignment operator + SceneInfo& operator=(const SceneInfo& rhs) = delete; ///< Assignment operator + SceneInfo(const SceneInfo& rhs) = delete; ///< Copy constructor - Layer* root{ nullptr }; ///< Root node (root is a layer). The layer is not stored in the node memory pool. - OwnerPointer< RenderTaskList > taskList; ///< Scene graph render task list - SortedLayerPointers sortedLayerList; ///< List of Layer pointers sorted by depth (one list of sorted layers per root) - OwnerPointer< Scene > scene; ///< Scene graph object of the scene + Layer* root{nullptr}; ///< Root node (root is a layer). The layer is not stored in the node memory pool. + OwnerPointer taskList; ///< Scene graph render task list + SortedLayerPointers sortedLayerList; ///< List of Layer pointers sorted by depth (one list of sorted layers per root) + OwnerPointer scene; ///< Scene graph object of the scene }; - Impl( NotificationManager& notificationManager, - CompleteNotificationInterface& animationPlaylist, - PropertyNotifier& propertyNotifier, - DiscardQueue& discardQueue, - RenderController& renderController, - RenderManager& renderManager, - RenderQueue& renderQueue, - SceneGraphBuffers& sceneGraphBuffers, - RenderTaskProcessor& renderTaskProcessor ) - : renderMessageDispatcher( renderManager, renderQueue, sceneGraphBuffers ), - notificationManager( notificationManager ), + Impl(NotificationManager& notificationManager, + CompleteNotificationInterface& animationPlaylist, + PropertyNotifier& propertyNotifier, + DiscardQueue& discardQueue, + RenderController& renderController, + RenderManager& renderManager, + RenderQueue& renderQueue, + SceneGraphBuffers& sceneGraphBuffers, + RenderTaskProcessor& renderTaskProcessor) + : renderMessageDispatcher(renderManager, renderQueue, sceneGraphBuffers), + notificationManager(notificationManager), transformManager(), - animationPlaylist( animationPlaylist ), - propertyNotifier( propertyNotifier ), - shaderSaver( NULL ), - discardQueue( discardQueue ), - renderController( renderController ), - sceneController( NULL ), - renderManager( renderManager ), - renderQueue( renderQueue ), - renderTaskProcessor( renderTaskProcessor ), - backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ), + animationPlaylist(animationPlaylist), + propertyNotifier(propertyNotifier), + shaderSaver(nullptr), + discardQueue(discardQueue), + renderController(renderController), + sceneController(nullptr), + renderManager(renderManager), + renderQueue(renderQueue), + renderTaskProcessor(renderTaskProcessor), + backgroundColor(Dali::DEFAULT_BACKGROUND_COLOR), renderers(), textureSets(), shaders(), - panGestureProcessor( NULL ), - messageQueue( renderController, sceneGraphBuffers ), - frameCallbackProcessor( NULL ), - keepRenderingSeconds( 0.0f ), - nodeDirtyFlags( NodePropertyFlags::TRANSFORM ), // set to TransformFlag to ensure full update the first time through Update() - frameCounter( 0 ), - renderingBehavior( DevelStage::Rendering::IF_REQUIRED ), - animationFinishedDuringUpdate( false ), - previousUpdateScene( false ), - renderTaskWaiting( false ), - renderersAdded( false ), - surfaceRectChanged( false ) + panGestureProcessor(nullptr), + messageQueue(renderController, sceneGraphBuffers), + frameCallbackProcessor(nullptr), + keepRenderingSeconds(0.0f), + nodeDirtyFlags(NodePropertyFlags::TRANSFORM), // set to TransformFlag to ensure full update the first time through Update() + frameCounter(0), + renderingBehavior(DevelStage::Rendering::IF_REQUIRED), + animationFinishedDuringUpdate(false), + previousUpdateScene(false), + renderTaskWaiting(false), + renderersAdded(false), + renderingRequired(false) { - sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue ); + sceneController = new SceneControllerImpl(renderMessageDispatcher, renderQueue, discardQueue); // create first 'dummy' node - nodes.PushBack(0u); + nodes.PushBack(nullptr); } ~Impl() { // Disconnect render tasks from nodes, before destroying the nodes - for( auto&& scene : scenes ) + for(auto&& scene : scenes) { - if ( scene && scene->taskList ) + if(scene && scene->taskList) { RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks(); - for ( auto&& task : tasks ) + for(auto&& task : tasks) { - task->SetSourceNode( NULL ); + task->SetSourceNode(nullptr); } } } // UpdateManager owns the Nodes. Although Nodes are pool allocated they contain heap allocated parts // like custom properties, which get released here - Vector::Iterator iter = nodes.Begin()+1; + Vector::Iterator iter = nodes.Begin() + 1; Vector::Iterator endIter = nodes.End(); - for(;iter!=endIter;++iter) + for(; iter != endIter; ++iter) { (*iter)->OnDestroy(); Node::Delete(*iter); } - for( auto&& scene : scenes ) + for(auto&& scene : scenes) { - if ( scene && scene->root ) + if(scene && scene->root) { scene->root->OnDestroy(); - Node::Delete( scene->root ); + Node::Delete(scene->root); } } scenes.clear(); delete sceneController; + + // Ensure to clear renderers + renderers.Clear(); + shaders.Clear(); } /** * Lazy init for FrameCallbackProcessor. * @param[in] updateManager A reference to the update-manager */ - FrameCallbackProcessor& GetFrameCallbackProcessor( UpdateManager& updateManager ) + FrameCallbackProcessor& GetFrameCallbackProcessor(UpdateManager& updateManager) { - if( ! frameCallbackProcessor ) + if(!frameCallbackProcessor) { - frameCallbackProcessor = new FrameCallbackProcessor( updateManager, transformManager ); + frameCallbackProcessor = new FrameCallbackProcessor(updateManager, transformManager); } return *frameCallbackProcessor; } - SceneGraphBuffers sceneGraphBuffers; ///< Used to keep track of which buffers are being written or read - RenderMessageDispatcher renderMessageDispatcher; ///< Used for passing messages to the render-thread - NotificationManager& notificationManager; ///< Queues notification messages for the event-thread. - TransformManager transformManager; ///< Used to update the transformation matrices of the nodes - CompleteNotificationInterface& animationPlaylist; ///< Holds handles to all the animations - PropertyNotifier& propertyNotifier; ///< Provides notification to applications when properties are modified. - ShaderSaver* shaderSaver; ///< Saves shader binaries. - DiscardQueue& discardQueue; ///< Nodes are added here when disconnected from the scene-graph. - RenderController& renderController; ///< render controller - SceneControllerImpl* sceneController; ///< scene controller - RenderManager& renderManager; ///< This is responsible for rendering the results of each "update" - RenderQueue& renderQueue; ///< Used to queue messages for the next render - RenderTaskProcessor& renderTaskProcessor; ///< Handles RenderTasks and RenderInstrucitons - - Vector4 backgroundColor; ///< The glClear color used at the beginning of each frame. - - using SceneInfoPtr = std::unique_ptr< SceneInfo >; - std::vector< SceneInfoPtr > scenes; ///< A container of SceneInfo. - - Vector nodes; ///< A container of all instantiated nodes - - OwnerContainer< Camera* > cameras; ///< A container of cameras - OwnerContainer< PropertyOwner* > customObjects; ///< A container of owned objects (with custom properties) - - OwnerContainer< PropertyResetterBase* > propertyResetters; ///< A container of property resetters - OwnerContainer< Animation* > animations; ///< A container of owned animations - PropertyNotificationContainer propertyNotifications; ///< A container of owner property notifications. - OwnerContainer< Renderer* > renderers; ///< A container of owned renderers - OwnerContainer< TextureSet* > textureSets; ///< A container of owned texture sets - OwnerContainer< Shader* > shaders; ///< A container of owned shaders - OwnerPointer< PanGesture > panGestureProcessor; ///< Owned pan gesture processor; it lives for the lifecycle of UpdateManager - - MessageQueue messageQueue; ///< The messages queued from the event-thread - std::vector renderCompiledShaders; ///< Shaders compiled on Render thread are inserted here for update thread to pass on to event thread. - std::vector updateCompiledShaders; ///< Shaders to be sent from Update to Event - Mutex compiledShaderMutex; ///< lock to ensure no corruption on the renderCompiledShaders - - OwnerPointer frameCallbackProcessor; ///< Owned FrameCallbackProcessor, only created if required. - - float keepRenderingSeconds; ///< Set via Dali::Stage::KeepRendering - NodePropertyFlags nodeDirtyFlags; ///< cumulative node dirty flags from previous frame - uint32_t frameCounter; ///< Frame counter used in debugging to choose which frame to debug and which to ignore. - - DevelStage::Rendering renderingBehavior; ///< Set via DevelStage::SetRenderingBehavior - - bool animationFinishedDuringUpdate; ///< Flag whether any animations finished during the Update() - bool previousUpdateScene; ///< True if the scene was updated in the previous frame (otherwise it was optimized out) - bool renderTaskWaiting; ///< A REFRESH_ONCE render task is waiting to be rendered - bool renderersAdded; ///< Flag to keep track when renderers have been added to avoid unnecessary processing - bool surfaceRectChanged; ///< True if the default surface rect is changed + SceneGraphBuffers sceneGraphBuffers; ///< Used to keep track of which buffers are being written or read + RenderMessageDispatcher renderMessageDispatcher; ///< Used for passing messages to the render-thread + NotificationManager& notificationManager; ///< Queues notification messages for the event-thread. + TransformManager transformManager; ///< Used to update the transformation matrices of the nodes + CompleteNotificationInterface& animationPlaylist; ///< Holds handles to all the animations + PropertyNotifier& propertyNotifier; ///< Provides notification to applications when properties are modified. + ShaderSaver* shaderSaver; ///< Saves shader binaries. + DiscardQueue& discardQueue; ///< Nodes are added here when disconnected from the scene-graph. + RenderController& renderController; ///< render controller + SceneControllerImpl* sceneController; ///< scene controller + RenderManager& renderManager; ///< This is responsible for rendering the results of each "update" + RenderQueue& renderQueue; ///< Used to queue messages for the next render + RenderTaskProcessor& renderTaskProcessor; ///< Handles RenderTasks and RenderInstrucitons + + Vector4 backgroundColor; ///< The glClear color used at the beginning of each frame. + + using SceneInfoPtr = std::unique_ptr; + std::vector scenes; ///< A container of SceneInfo. + + Vector nodes; ///< A container of all instantiated nodes + + OwnerContainer cameras; ///< A container of cameras + OwnerContainer customObjects; ///< A container of owned objects (with custom properties) + + OwnerContainer propertyResetters; ///< A container of property resetters + OwnerContainer nodeResetters; ///< A container of node resetters + OwnerContainer animations; ///< A container of owned animations + PropertyNotificationContainer propertyNotifications; ///< A container of owner property notifications. + OwnerContainer renderers; ///< A container of owned renderers + OwnerContainer textureSets; ///< A container of owned texture sets + OwnerContainer shaders; ///< A container of owned shaders + OwnerPointer panGestureProcessor; ///< Owned pan gesture processor; it lives for the lifecycle of UpdateManager + + MessageQueue messageQueue; ///< The messages queued from the event-thread + std::vector renderCompiledShaders; ///< Shaders compiled on Render thread are inserted here for update thread to pass on to event thread. + std::vector updateCompiledShaders; ///< Shaders to be sent from Update to Event + Mutex compiledShaderMutex; ///< lock to ensure no corruption on the renderCompiledShaders + + OwnerPointer frameCallbackProcessor; ///< Owned FrameCallbackProcessor, only created if required. + + float keepRenderingSeconds; ///< Set via Dali::Stage::KeepRendering + NodePropertyFlags nodeDirtyFlags; ///< cumulative node dirty flags from previous frame + uint32_t frameCounter; ///< Frame counter used in debugging to choose which frame to debug and which to ignore. + + DevelStage::Rendering renderingBehavior; ///< Set via DevelStage::SetRenderingBehavior + + bool animationFinishedDuringUpdate; ///< Flag whether any animations finished during the Update() + bool previousUpdateScene; ///< True if the scene was updated in the previous frame (otherwise it was optimized out) + bool renderTaskWaiting; ///< A REFRESH_ONCE render task is waiting to be rendered + bool renderersAdded; ///< Flag to keep track when renderers have been added to avoid unnecessary processing + bool renderingRequired; ///< True if required to render the current frame private: - - Impl( const Impl& ); ///< Undefined - Impl& operator=( const Impl& ); ///< Undefined + Impl(const Impl&); ///< Undefined + Impl& operator=(const Impl&); ///< Undefined }; -UpdateManager::UpdateManager( NotificationManager& notificationManager, - CompleteNotificationInterface& animationFinishedNotifier, - PropertyNotifier& propertyNotifier, - DiscardQueue& discardQueue, - RenderController& controller, - RenderManager& renderManager, - RenderQueue& renderQueue, - RenderTaskProcessor& renderTaskProcessor ) - : mImpl(NULL) -{ - mImpl = new Impl( notificationManager, - animationFinishedNotifier, - propertyNotifier, - discardQueue, - controller, - renderManager, - renderQueue, - mSceneGraphBuffers, - renderTaskProcessor ); - +UpdateManager::UpdateManager(NotificationManager& notificationManager, + CompleteNotificationInterface& animationFinishedNotifier, + PropertyNotifier& propertyNotifier, + DiscardQueue& discardQueue, + RenderController& controller, + RenderManager& renderManager, + RenderQueue& renderQueue, + RenderTaskProcessor& renderTaskProcessor) +: mImpl(nullptr) +{ + mImpl = new Impl(notificationManager, + animationFinishedNotifier, + propertyNotifier, + discardQueue, + controller, + renderManager, + renderQueue, + mSceneGraphBuffers, + renderTaskProcessor); } UpdateManager::~UpdateManager() @@ -332,110 +330,103 @@ UpdateManager::~UpdateManager() delete mImpl; } -void UpdateManager::InstallRoot( OwnerPointer& layer ) +void UpdateManager::InstallRoot(OwnerPointer& layer) { - DALI_ASSERT_DEBUG( layer->IsLayer() ); - DALI_ASSERT_DEBUG( layer->GetParent() == NULL); + DALI_ASSERT_DEBUG(layer->IsLayer()); + DALI_ASSERT_DEBUG(layer->GetParent() == NULL); Layer* rootLayer = layer.Release(); - DALI_ASSERT_DEBUG( std::find_if( mImpl->scenes.begin(), mImpl->scenes.end(), - [rootLayer]( Impl::SceneInfoPtr& scene ) - { - return scene && scene->root == rootLayer; - } - ) == mImpl->scenes.end() && "Root Node already installed" ); + DALI_ASSERT_DEBUG(std::find_if(mImpl->scenes.begin(), mImpl->scenes.end(), [rootLayer](Impl::SceneInfoPtr& scene) { + return scene && scene->root == rootLayer; + }) == mImpl->scenes.end() && + "Root Node already installed"); - rootLayer->CreateTransform( &mImpl->transformManager ); + rootLayer->CreateTransform(&mImpl->transformManager); rootLayer->SetRoot(true); - mImpl->scenes.emplace_back( new Impl::SceneInfo( rootLayer ) ); + AddNodeResetter(*rootLayer); + + mImpl->scenes.emplace_back(new Impl::SceneInfo(rootLayer)); } -void UpdateManager::UninstallRoot( Layer* layer ) +void UpdateManager::UninstallRoot(Layer* layer) { - DALI_ASSERT_DEBUG( layer->IsLayer() ); - DALI_ASSERT_DEBUG( layer->GetParent() == NULL ); + DALI_ASSERT_DEBUG(layer->IsLayer()); + DALI_ASSERT_DEBUG(layer->GetParent() == NULL); - for (auto iter = mImpl->scenes.begin(); iter != mImpl->scenes.end(); ++iter) + for(auto iter = mImpl->scenes.begin(); iter != mImpl->scenes.end(); ++iter) { - if( (*iter) && (*iter)->root == layer ) + if((*iter) && (*iter)->root == layer) { - mImpl->scenes.erase( iter ); + mImpl->scenes.erase(iter); break; } } - mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), layer ); + mImpl->discardQueue.Add(mSceneGraphBuffers.GetUpdateBufferIndex(), layer); // Notify the layer about impending destruction layer->OnDestroy(); } -void UpdateManager::AddNode( OwnerPointer& node ) +void UpdateManager::AddNode(OwnerPointer& node) { - DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet + DALI_ASSERT_ALWAYS(nullptr == node->GetParent()); // Should not have a parent yet - // Nodes must be sorted by pointer Node* rawNode = node.Release(); - DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] AddNode\n", rawNode ); + DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] AddNode\n", rawNode); - Vector::Iterator begin = mImpl->nodes.Begin(); - for( Vector::Iterator iter = mImpl->nodes.End()-1; iter >= begin; --iter ) - { - if( rawNode > (*iter) ) - { - mImpl->nodes.Insert((iter+1), rawNode ); - rawNode->CreateTransform( &mImpl->transformManager ); - return; - } - } + mImpl->nodes.PushBack(rawNode); + rawNode->CreateTransform(&mImpl->transformManager); } -void UpdateManager::ConnectNode( Node* parent, Node* node ) +void UpdateManager::ConnectNode(Node* parent, Node* node) { - DALI_ASSERT_ALWAYS( NULL != parent ); - DALI_ASSERT_ALWAYS( NULL != node ); - DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet + DALI_ASSERT_ALWAYS(nullptr != parent); + DALI_ASSERT_ALWAYS(nullptr != node); + DALI_ASSERT_ALWAYS(nullptr == node->GetParent()); // Should not have a parent yet + + DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] ConnectNode\n", node); - DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] ConnectNode\n", node ); + parent->ConnectChild(node); - parent->ConnectChild( node ); + AddNodeResetter(*node); // Inform the frame-callback-processor, if set, about the node-hierarchy changing - if( mImpl->frameCallbackProcessor ) + if(mImpl->frameCallbackProcessor) { mImpl->frameCallbackProcessor->NodeHierarchyChanged(); } } -void UpdateManager::DisconnectNode( Node* node ) +void UpdateManager::DisconnectNode(Node* node) { - DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] DisconnectNode\n", node ); + DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] DisconnectNode\n", node); Node* parent = node->GetParent(); - DALI_ASSERT_ALWAYS( NULL != parent ); - parent->SetDirtyFlag( NodePropertyFlags::CHILD_DELETED ); // make parent dirty so that render items dont get reused + DALI_ASSERT_ALWAYS(nullptr != parent); + parent->SetDirtyFlag(NodePropertyFlags::CHILD_DELETED); // make parent dirty so that render items dont get reused - parent->DisconnectChild( mSceneGraphBuffers.GetUpdateBufferIndex(), *node ); + parent->DisconnectChild(mSceneGraphBuffers.GetUpdateBufferIndex(), *node); // Inform the frame-callback-processor, if set, about the node-hierarchy changing - if( mImpl->frameCallbackProcessor ) + if(mImpl->frameCallbackProcessor) { mImpl->frameCallbackProcessor->NodeHierarchyChanged(); } } -void UpdateManager::DestroyNode( Node* node ) +void UpdateManager::DestroyNode(Node* node) { - DALI_ASSERT_ALWAYS( NULL != node ); - DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should have been disconnected + DALI_ASSERT_ALWAYS(nullptr != node); + DALI_ASSERT_ALWAYS(nullptr == node->GetParent()); // Should have been disconnected - DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] DestroyNode\n", node ); + DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] DestroyNode\n", node); - Vector::Iterator iter = mImpl->nodes.Begin()+1; + Vector::Iterator iter = mImpl->nodes.Begin() + 1; Vector::Iterator endIter = mImpl->nodes.End(); - for(;iter!=endIter;++iter) + for(; iter != endIter; ++iter) { if((*iter) == node) { @@ -444,46 +435,46 @@ void UpdateManager::DestroyNode( Node* node ) } } - mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), node ); + mImpl->discardQueue.Add(mSceneGraphBuffers.GetUpdateBufferIndex(), node); // Notify the Node about impending destruction node->OnDestroy(); } -void UpdateManager::AddCamera( OwnerPointer< Camera >& camera ) +void UpdateManager::AddCamera(OwnerPointer& camera) { - mImpl->cameras.PushBack( camera.Release() ); // takes ownership + mImpl->cameras.PushBack(camera.Release()); // takes ownership } -void UpdateManager::RemoveCamera( Camera* camera ) +void UpdateManager::RemoveCamera(Camera* camera) { // Find the camera and destroy it - EraseUsingDiscardQueue( mImpl->cameras, camera, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() ); + EraseUsingDiscardQueue(mImpl->cameras, camera, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex()); } -void UpdateManager::AddObject( OwnerPointer& object ) +void UpdateManager::AddObject(OwnerPointer& object) { - mImpl->customObjects.PushBack( object.Release() ); + mImpl->customObjects.PushBack(object.Release()); } -void UpdateManager::RemoveObject( PropertyOwner* object ) +void UpdateManager::RemoveObject(PropertyOwner* object) { - mImpl->customObjects.EraseObject( object ); + mImpl->customObjects.EraseObject(object); } -void UpdateManager::AddRenderTaskList( OwnerPointer& taskList ) +void UpdateManager::AddRenderTaskList(OwnerPointer& taskList) { RenderTaskList* taskListPointer = taskList.Release(); - taskListPointer->SetRenderMessageDispatcher( &mImpl->renderMessageDispatcher ); + taskListPointer->SetRenderMessageDispatcher(&mImpl->renderMessageDispatcher); mImpl->scenes.back()->taskList = taskListPointer; } -void UpdateManager::RemoveRenderTaskList( RenderTaskList* taskList ) +void UpdateManager::RemoveRenderTaskList(RenderTaskList* taskList) { - for ( auto&& scene : mImpl->scenes ) + for(auto&& scene : mImpl->scenes) { - if ( scene && scene->taskList == taskList ) + if(scene && scene->taskList == taskList) { scene->taskList.Reset(); break; @@ -491,74 +482,78 @@ void UpdateManager::RemoveRenderTaskList( RenderTaskList* taskList ) } } -void UpdateManager::AddScene( OwnerPointer< Scene >& scene ) +void UpdateManager::AddScene(OwnerPointer& scene) { - mImpl->scenes.back()->scene = scene.Release(); + auto& sceneInfo = mImpl->scenes.back(); + sceneInfo->scene = scene.Release(); + + // Set root to the Scene + sceneInfo->scene->SetRoot(sceneInfo->root); // Initialize the context from render manager - typedef MessageValue1< RenderManager, SceneGraph::Scene* > DerivedType; + typedef MessageValue1 DerivedType; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - SceneGraph::Scene& sceneObject = *mImpl->scenes.back()->scene; - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::InitializeScene, &sceneObject ); + SceneGraph::Scene& sceneObject = *sceneInfo->scene; + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::InitializeScene, &sceneObject); } -void UpdateManager::RemoveScene( Scene* scene ) +void UpdateManager::RemoveScene(Scene* scene) { // Initialize the context from render manager - typedef MessageValue1< RenderManager, SceneGraph::Scene* > DerivedType; + using DerivedType = MessageValue1; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UninitializeScene, scene ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::UninitializeScene, scene); - for ( auto&& sceneInfo : mImpl->scenes ) + for(auto&& sceneInfo : mImpl->scenes) { - if ( sceneInfo && sceneInfo->scene && sceneInfo->scene.Get() == scene ) + if(sceneInfo && sceneInfo->scene && sceneInfo->scene.Get() == scene) { - mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), sceneInfo->scene.Release() ); // take the address of the reference to a pointer + mImpl->discardQueue.Add(mSceneGraphBuffers.GetUpdateBufferIndex(), sceneInfo->scene.Release()); // take the address of the reference to a pointer break; } } } -void UpdateManager::AddAnimation( OwnerPointer< SceneGraph::Animation >& animation ) +void UpdateManager::AddAnimation(OwnerPointer& animation) { - mImpl->animations.PushBack( animation.Release() ); + mImpl->animations.PushBack(animation.Release()); } -void UpdateManager::StopAnimation( Animation* animation ) +void UpdateManager::StopAnimation(Animation* animation) { - DALI_ASSERT_DEBUG( animation && "NULL animation called to stop" ); + DALI_ASSERT_DEBUG(animation && "NULL animation called to stop"); - bool animationFinished = animation->Stop( mSceneGraphBuffers.GetUpdateBufferIndex() ); + bool animationFinished = animation->Stop(mSceneGraphBuffers.GetUpdateBufferIndex()); mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || animationFinished; } -void UpdateManager::RemoveAnimation( Animation* animation ) +void UpdateManager::RemoveAnimation(Animation* animation) { - DALI_ASSERT_DEBUG( animation && "NULL animation called to remove" ); + DALI_ASSERT_DEBUG(animation && "NULL animation called to remove"); - animation->OnDestroy( mSceneGraphBuffers.GetUpdateBufferIndex() ); + animation->OnDestroy(mSceneGraphBuffers.GetUpdateBufferIndex()); - DALI_ASSERT_DEBUG( animation->GetState() == Animation::Destroyed ); + DALI_ASSERT_DEBUG(animation->GetState() == Animation::Destroyed); } bool UpdateManager::IsAnimationRunning() const { // Find any animation that isn't stopped or paused - for ( auto&& iter : mImpl->animations ) + for(auto&& iter : mImpl->animations) { const Animation::State state = iter->GetState(); - if (state != Animation::Stopped && - state != Animation::Paused) + if(state != Animation::Stopped && + state != Animation::Paused) { return true; // stop iteration as soon as first one is found } @@ -567,110 +562,106 @@ bool UpdateManager::IsAnimationRunning() const return false; } -void UpdateManager::AddPropertyResetter( OwnerPointer& propertyResetter ) +void UpdateManager::AddPropertyResetter(OwnerPointer& propertyResetter) { propertyResetter->Initialize(); - mImpl->propertyResetters.PushBack( propertyResetter.Release() ); + mImpl->propertyResetters.PushBack(propertyResetter.Release()); } -void UpdateManager::AddPropertyNotification( OwnerPointer< PropertyNotification >& propertyNotification ) +void UpdateManager::AddNodeResetter(const Node& node) { - mImpl->propertyNotifications.PushBack( propertyNotification.Release() ); + OwnerPointer nodeResetter = SceneGraph::NodeResetter::New(node); + nodeResetter->Initialize(); + mImpl->nodeResetters.PushBack(nodeResetter.Release()); } -void UpdateManager::RemovePropertyNotification( PropertyNotification* propertyNotification ) +void UpdateManager::AddPropertyNotification(OwnerPointer& propertyNotification) { - mImpl->propertyNotifications.EraseObject( propertyNotification ); + mImpl->propertyNotifications.PushBack(propertyNotification.Release()); } -void UpdateManager::PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode ) +void UpdateManager::RemovePropertyNotification(PropertyNotification* propertyNotification) { - DALI_ASSERT_DEBUG( propertyNotification && "propertyNotification scene graph object missing" ); - propertyNotification->SetNotifyMode( notifyMode ); + mImpl->propertyNotifications.EraseObject(propertyNotification); } -void UpdateManager::AddShader( OwnerPointer< Shader >& shader ) +void UpdateManager::PropertyNotificationSetNotify(PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode) { - mImpl->shaders.PushBack( shader.Release() ); + DALI_ASSERT_DEBUG(propertyNotification && "propertyNotification scene graph object missing"); + propertyNotification->SetNotifyMode(notifyMode); } -void UpdateManager::RemoveShader( Shader* shader ) +void UpdateManager::AddShader(OwnerPointer& shader) { - // Find the shader and destroy it - EraseUsingDiscardQueue( mImpl->shaders, shader, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() ); + mImpl->shaders.PushBack(shader.Release()); } -void UpdateManager::SetShaderProgram( Shader* shader, - Internal::ShaderDataPtr shaderData, bool modifiesGeometry ) +void UpdateManager::RemoveShader(Shader* shader) { - if( shaderData ) - { - - typedef MessageValue3< Shader, Internal::ShaderDataPtr, ProgramCache*, bool> DerivedType; - - // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); - - // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( shader, &Shader::SetProgram, shaderData, mImpl->renderManager.GetProgramCache(), modifiesGeometry ); - } + // Find the shader and destroy it + EraseUsingDiscardQueue(mImpl->shaders, shader, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex()); } -void UpdateManager::SaveBinary( Internal::ShaderDataPtr shaderData ) +void UpdateManager::SaveBinary(Internal::ShaderDataPtr shaderData) { - DALI_ASSERT_DEBUG( shaderData && "No NULL shader data pointers please." ); - DALI_ASSERT_DEBUG( shaderData->GetBufferSize() > 0 && "Shader binary empty so nothing to save." ); + DALI_ASSERT_DEBUG(shaderData && "No NULL shader data pointers please."); + DALI_ASSERT_DEBUG(shaderData->GetBufferSize() > 0 && "Shader binary empty so nothing to save."); { // lock as update might be sending previously compiled shaders to event thread - Mutex::ScopedLock lock( mImpl->compiledShaderMutex ); - mImpl->renderCompiledShaders.push_back( shaderData ); + Mutex::ScopedLock lock(mImpl->compiledShaderMutex); + mImpl->renderCompiledShaders.push_back(shaderData); } } -void UpdateManager::SetShaderSaver( ShaderSaver& upstream ) +void UpdateManager::SetShaderSaver(ShaderSaver& upstream) { mImpl->shaderSaver = &upstream; } -void UpdateManager::AddRenderer( OwnerPointer< Renderer >& renderer ) +void UpdateManager::AddRenderer(OwnerPointer& renderer) { - DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] AddRenderer\n", renderer.Get() ); + DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] AddRenderer\n", renderer.Get()); - renderer->ConnectToSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() ); - mImpl->renderers.PushBack( renderer.Release() ); - mImpl->renderersAdded = true; + renderer->ConnectToSceneGraph(*mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex()); + mImpl->renderers.PushBack(renderer.Release()); } -void UpdateManager::RemoveRenderer( Renderer* renderer ) +void UpdateManager::RemoveRenderer(Renderer* renderer) { - DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] RemoveRenderer\n", renderer ); + DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] RemoveRenderer\n", renderer); // Find the renderer and destroy it - EraseUsingDiscardQueue( mImpl->renderers, renderer, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() ); + EraseUsingDiscardQueue(mImpl->renderers, renderer, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex()); // Need to remove the render object as well - renderer->DisconnectFromSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() ); + renderer->DisconnectFromSceneGraph(*mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex()); } -void UpdateManager::SetPanGestureProcessor( PanGesture* panGestureProcessor ) +void UpdateManager::AttachRenderer(Node* node, Renderer* renderer) { - DALI_ASSERT_DEBUG( NULL != panGestureProcessor ); + node->AddRenderer(renderer); + mImpl->renderersAdded = true; +} + +void UpdateManager::SetPanGestureProcessor(PanGesture* panGestureProcessor) +{ + DALI_ASSERT_DEBUG(NULL != panGestureProcessor); mImpl->panGestureProcessor = panGestureProcessor; } -void UpdateManager::AddTextureSet( OwnerPointer< TextureSet >& textureSet ) +void UpdateManager::AddTextureSet(OwnerPointer& textureSet) { - mImpl->textureSets.PushBack( textureSet.Release() ); + mImpl->textureSets.PushBack(textureSet.Release()); } -void UpdateManager::RemoveTextureSet( TextureSet* textureSet ) +void UpdateManager::RemoveTextureSet(TextureSet* textureSet) { - mImpl->textureSets.EraseObject( textureSet ); + mImpl->textureSets.EraseObject(textureSet); } -uint32_t* UpdateManager::ReserveMessageSlot( uint32_t size, bool updateScene ) +uint32_t* UpdateManager::ReserveMessageSlot(uint32_t size, bool updateScene) { - return mImpl->messageQueue.ReserveMessageSlot( size, updateScene ); + return mImpl->messageQueue.ReserveMessageSlot(size, updateScene); } void UpdateManager::EventProcessingStarted() @@ -683,81 +674,102 @@ bool UpdateManager::FlushQueue() return mImpl->messageQueue.FlushQueue(); } -void UpdateManager::ResetProperties( BufferIndex bufferIndex ) +void UpdateManager::ResetProperties(BufferIndex bufferIndex) { // Clear the "animations finished" flag; This should be set if any (previously playing) animation is stopped mImpl->animationFinishedDuringUpdate = false; + // Reset node properties + std::vector nodeResetterToDelete; + for(auto&& element : mImpl->nodeResetters) + { + element->ResetToBaseValue(bufferIndex); + if(element->IsFinished()) + { + nodeResetterToDelete.push_back(element); + } + } + + // If a node resetter is no longer required, delete it. + for(auto&& elementPtr : nodeResetterToDelete) + { + mImpl->nodeResetters.EraseObject(elementPtr); + } + // Reset all animating / constrained properties - std::vectortoDelete; - for( auto&& element : mImpl->propertyResetters ) + std::vector propertyResettertoDelete; + for(auto&& element : mImpl->propertyResetters) { - element->ResetToBaseValue( bufferIndex ); - if( element->IsFinished() ) + element->ResetToBaseValue(bufferIndex); + if(element->IsFinished()) { - toDelete.push_back( element ); + propertyResettertoDelete.push_back(element); } } - // If a resetter is no longer required (the animator or constraint has been removed), delete it. - for( auto&& elementPtr : toDelete ) + // If a property resetter is no longer required (the animator or constraint has been removed), delete it. + for(auto&& elementPtr : propertyResettertoDelete) { - mImpl->propertyResetters.EraseObject( elementPtr ); + mImpl->propertyResetters.EraseObject(elementPtr); } // Clear all root nodes dirty flags - for( auto& scene : mImpl->scenes ) + for(auto& scene : mImpl->scenes) { auto root = scene->root; - root->ResetDirtyFlags( bufferIndex ); + root->ResetDirtyFlags(bufferIndex); } // Clear node dirty flags - Vector::Iterator iter = mImpl->nodes.Begin()+1; + Vector::Iterator iter = mImpl->nodes.Begin() + 1; Vector::Iterator endIter = mImpl->nodes.End(); - for( ;iter != endIter; ++iter ) + for(; iter != endIter; ++iter) { - (*iter)->ResetDirtyFlags( bufferIndex ); + (*iter)->ResetDirtyFlags(bufferIndex); } } -bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, uint32_t lastVSyncTimeMilliseconds, uint32_t nextVSyncTimeMilliseconds ) +bool UpdateManager::ProcessGestures(BufferIndex bufferIndex, uint32_t lastVSyncTimeMilliseconds, uint32_t nextVSyncTimeMilliseconds) { - bool gestureUpdated( false ); + bool gestureUpdated(false); - if( mImpl->panGestureProcessor ) + if(mImpl->panGestureProcessor) { // gesture processor only supports default properties - 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 - gestureUpdated |= mImpl->panGestureProcessor->UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds ); + 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 + gestureUpdated |= mImpl->panGestureProcessor->UpdateProperties(lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds); } return gestureUpdated; } -void UpdateManager::Animate( BufferIndex bufferIndex, float elapsedSeconds ) +bool UpdateManager::Animate(BufferIndex bufferIndex, float elapsedSeconds) { - auto&& iter = mImpl->animations.Begin(); - bool animationLooped = false; + bool animationActive = false; + + auto&& iter = mImpl->animations.Begin(); + bool animationLooped = false; - while ( iter != mImpl->animations.End() ) + while(iter != mImpl->animations.End()) { - Animation* animation = *iter; - bool finished = false; - bool looped = false; - bool progressMarkerReached = false; - animation->Update( bufferIndex, elapsedSeconds, looped, finished, progressMarkerReached ); + Animation* animation = *iter; + bool finished = false; + bool looped = false; + bool progressMarkerReached = false; + animation->Update(bufferIndex, elapsedSeconds, looped, finished, progressMarkerReached); - if ( progressMarkerReached ) + animationActive = animationActive || animation->IsActive(); + + if(progressMarkerReached) { - mImpl->notificationManager.QueueMessage( Internal::NotifyProgressReachedMessage( mImpl->animationPlaylist, animation ) ); + mImpl->notificationManager.QueueMessage(Internal::NotifyProgressReachedMessage(mImpl->animationPlaylist, animation)); } mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || finished; - animationLooped = animationLooped || looped; + animationLooped = animationLooped || looped; // Remove animations that had been destroyed but were still waiting for an update - if (animation->GetState() == Animation::Destroyed) + if(animation->GetState() == Animation::Destroyed) { iter = mImpl->animations.Erase(iter); } @@ -768,77 +780,79 @@ void UpdateManager::Animate( BufferIndex bufferIndex, float elapsedSeconds ) } // queue the notification on finished or looped (to update loop count) - if ( mImpl->animationFinishedDuringUpdate || animationLooped ) + if(mImpl->animationFinishedDuringUpdate || animationLooped) { // The application should be notified by NotificationManager, in another thread - mImpl->notificationManager.QueueCompleteNotification( &mImpl->animationPlaylist ); + mImpl->notificationManager.QueueCompleteNotification(&mImpl->animationPlaylist); } + + return animationActive; } -void UpdateManager::ConstrainCustomObjects( BufferIndex bufferIndex ) +void UpdateManager::ConstrainCustomObjects(BufferIndex bufferIndex) { //Constrain custom objects (in construction order) - for ( auto&& object : mImpl->customObjects ) + for(auto&& object : mImpl->customObjects) { - ConstrainPropertyOwner( *object, bufferIndex ); + ConstrainPropertyOwner(*object, bufferIndex); } } -void UpdateManager::ConstrainRenderTasks( BufferIndex bufferIndex ) +void UpdateManager::ConstrainRenderTasks(BufferIndex bufferIndex) { // Constrain render-tasks - for ( auto&& scene : mImpl->scenes ) + for(auto&& scene : mImpl->scenes) { - if ( scene && scene->taskList ) + if(scene && scene->taskList) { RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks(); - for ( auto&& task : tasks ) + for(auto&& task : tasks) { - ConstrainPropertyOwner( *task, bufferIndex ); + ConstrainPropertyOwner(*task, bufferIndex); } } } } -void UpdateManager::ConstrainShaders( BufferIndex bufferIndex ) +void UpdateManager::ConstrainShaders(BufferIndex bufferIndex) { // constrain shaders... (in construction order) - for ( auto&& shader : mImpl->shaders ) + for(auto&& shader : mImpl->shaders) { - ConstrainPropertyOwner( *shader, bufferIndex ); + ConstrainPropertyOwner(*shader, bufferIndex); } } -void UpdateManager::ProcessPropertyNotifications( BufferIndex bufferIndex ) +void UpdateManager::ProcessPropertyNotifications(BufferIndex bufferIndex) { - for( auto&& notification : mImpl->propertyNotifications ) + for(auto&& notification : mImpl->propertyNotifications) { - bool valid = notification->Check( bufferIndex ); + bool valid = notification->Check(bufferIndex); if(valid) { - mImpl->notificationManager.QueueMessage( PropertyChangedMessage( mImpl->propertyNotifier, notification, notification->GetValidity() ) ); + mImpl->notificationManager.QueueMessage(PropertyChangedMessage(mImpl->propertyNotifier, notification, notification->GetValidity())); } } } void UpdateManager::ForwardCompiledShadersToEventThread() { - DALI_ASSERT_DEBUG( (mImpl->shaderSaver != 0) && "shaderSaver should be wired-up during startup." ); - if( mImpl->shaderSaver ) + DALI_ASSERT_DEBUG((mImpl->shaderSaver != 0) && "shaderSaver should be wired-up during startup."); + if(mImpl->shaderSaver) { // lock and swap the queues { // render might be attempting to send us more binaries at the same time - Mutex::ScopedLock lock( mImpl->compiledShaderMutex ); - mImpl->renderCompiledShaders.swap( mImpl->updateCompiledShaders ); + Mutex::ScopedLock lock(mImpl->compiledShaderMutex); + mImpl->renderCompiledShaders.swap(mImpl->updateCompiledShaders); } - if( mImpl->updateCompiledShaders.size() > 0 ) + if(mImpl->updateCompiledShaders.size() > 0) { ShaderSaver& factory = *mImpl->shaderSaver; - for( auto&& shader : mImpl->updateCompiledShaders ) + for(auto&& shader : mImpl->updateCompiledShaders) { - mImpl->notificationManager.QueueMessage( ShaderCompiledMessage( factory, shader ) ); + mImpl->notificationManager.QueueMessage(ShaderCompiledMessage(factory, shader)); } // we don't need them in update anymore mImpl->updateCompiledShaders.clear(); @@ -846,69 +860,85 @@ void UpdateManager::ForwardCompiledShadersToEventThread() } } -void UpdateManager::UpdateRenderers( BufferIndex bufferIndex ) +void UpdateManager::UpdateRenderers(BufferIndex bufferIndex) { - for( auto&& renderer : mImpl->renderers ) + for(auto&& renderer : mImpl->renderers) { //Apply constraints - ConstrainPropertyOwner( *renderer, bufferIndex ); + ConstrainPropertyOwner(*renderer, bufferIndex); - renderer->PrepareRender( bufferIndex ); + mImpl->renderingRequired = renderer->PrepareRender(bufferIndex) || mImpl->renderingRequired; } } -void UpdateManager::UpdateNodes( BufferIndex bufferIndex ) +void UpdateManager::UpdateNodes(BufferIndex bufferIndex) { mImpl->nodeDirtyFlags = NodePropertyFlags::NOTHING; - for ( auto&& scene : mImpl->scenes ) + for(auto&& scene : mImpl->scenes) { - if ( scene && scene->root ) + if(scene && scene->root) { // Prepare resources, update shaders, for each node // And add the renderers to the sorted layers. Start from root, which is also a layer - mImpl->nodeDirtyFlags |= UpdateNodeTree( *scene->root, + mImpl->nodeDirtyFlags |= UpdateNodeTree(*scene->root, bufferIndex, - mImpl->renderQueue ); + mImpl->renderQueue); } } } -uint32_t UpdateManager::Update( float elapsedSeconds, - uint32_t lastVSyncTimeMilliseconds, - uint32_t nextVSyncTimeMilliseconds, - bool renderToFboEnabled, - bool isRenderingToFbo ) +void UpdateManager::UpdateLayers(BufferIndex bufferIndex) +{ + for(auto&& scene : mImpl->scenes) + { + if(scene && scene->root) + { + SceneGraph::UpdateLayerTree(*scene->root, bufferIndex); + } + } +} + +uint32_t UpdateManager::Update(float elapsedSeconds, + uint32_t lastVSyncTimeMilliseconds, + uint32_t nextVSyncTimeMilliseconds, + bool renderToFboEnabled, + bool isRenderingToFbo, + bool uploadOnly) { const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex(); //Clear nodes/resources which were previously discarded - mImpl->discardQueue.Clear( bufferIndex ); + mImpl->discardQueue.Clear(bufferIndex); + + bool isAnimationRunning = IsAnimationRunning(); //Process Touches & Gestures - const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds ); + const bool gestureUpdated = ProcessGestures(bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds); - bool updateScene = // The scene-graph requires an update if.. - (mImpl->nodeDirtyFlags & RenderableUpdateFlags) || // ..nodes were dirty in previous frame OR - IsAnimationRunning() || // ..at least one animation is running OR - mImpl->messageQueue.IsSceneUpdateRequired() || // ..a message that modifies the scene graph node tree is queued OR - gestureUpdated; // ..a gesture property was updated + bool updateScene = // The scene-graph requires an update if.. + (mImpl->nodeDirtyFlags & RenderableUpdateFlags) || // ..nodes were dirty in previous frame OR + isAnimationRunning || // ..at least one animation is running OR + mImpl->messageQueue.IsSceneUpdateRequired() || // ..a message that modifies the scene graph node tree is queued OR + mImpl->frameCallbackProcessor || // ..a frame callback processor is existed OR + gestureUpdated; // ..a gesture property was updated bool keepRendererRendering = false; + mImpl->renderingRequired = false; // Although the scene-graph may not require an update, we still need to synchronize double-buffered // values if the scene was updated in the previous frame. - if( updateScene || mImpl->previousUpdateScene ) + if(updateScene || mImpl->previousUpdateScene) { //Reset properties from the previous update - ResetProperties( bufferIndex ); + ResetProperties(bufferIndex); mImpl->transformManager.ResetToBaseValue(); } // Process the queued scene messages. Note, MessageQueue::FlushQueue may be called // between calling IsSceneUpdateRequired() above and here, so updateScene should // be set again - updateScene |= mImpl->messageQueue.ProcessMessages( bufferIndex ); + updateScene |= mImpl->messageQueue.ProcessMessages(bufferIndex); //Forward compiled shader programs to event thread for saving ForwardCompiledShadersToEventThread(); @@ -916,22 +946,22 @@ uint32_t UpdateManager::Update( float elapsedSeconds, // Although the scene-graph may not require an update, we still need to synchronize double-buffered // renderer lists if the scene was updated in the previous frame. // We should not start skipping update steps or reusing lists until there has been two frames where nothing changes - if( updateScene || mImpl->previousUpdateScene ) + if(updateScene || mImpl->previousUpdateScene) { //Animate - Animate( bufferIndex, elapsedSeconds ); + bool animationActive = Animate(bufferIndex, elapsedSeconds); //Constraint custom objects - ConstrainCustomObjects( bufferIndex ); + ConstrainCustomObjects(bufferIndex); //Clear the lists of renderers from the previous update - for( auto&& scene : mImpl->scenes ) + for(auto&& scene : mImpl->scenes) { - if ( scene ) + if(scene) { - for( auto&& layer : scene->sortedLayerList ) + for(auto&& layer : scene->sortedLayerList) { - if ( layer ) + if(layer) { layer->ClearRenderables(); } @@ -940,105 +970,121 @@ uint32_t UpdateManager::Update( float elapsedSeconds, } // Call the frame-callback-processor if set - if( mImpl->frameCallbackProcessor ) + if(mImpl->frameCallbackProcessor) { - mImpl->frameCallbackProcessor->Update( bufferIndex, elapsedSeconds ); + mImpl->frameCallbackProcessor->Update(bufferIndex, elapsedSeconds); } - //Update node hierarchy, apply constraints and perform sorting / culling. - //This will populate each Layer with a list of renderers which are ready. - UpdateNodes( bufferIndex ); + //Update node hierarchy, apply constraints, + UpdateNodes(bufferIndex); //Apply constraints to RenderTasks, shaders - ConstrainRenderTasks( bufferIndex ); - ConstrainShaders( bufferIndex ); + ConstrainRenderTasks(bufferIndex); + ConstrainShaders(bufferIndex); //Update renderers and apply constraints - UpdateRenderers( bufferIndex ); + UpdateRenderers(bufferIndex); //Update the transformations of all the nodes - mImpl->transformManager.Update(); + if(mImpl->transformManager.Update()) + { + mImpl->nodeDirtyFlags |= NodePropertyFlags::TRANSFORM; + } + + //Initialise layer renderable reuse + UpdateLayers(bufferIndex); //Process Property Notifications - ProcessPropertyNotifications( bufferIndex ); + ProcessPropertyNotifications(bufferIndex); //Update cameras - for( auto&& cameraIterator : mImpl->cameras ) + for(auto&& cameraIterator : mImpl->cameras) { - cameraIterator->Update( bufferIndex ); + cameraIterator->Update(bufferIndex); } //Process the RenderTasks if renderers exist. This creates the instructions for rendering the next frame. //reset the update buffer index and make sure there is enough room in the instruction container - if( mImpl->renderersAdded ) + if(mImpl->renderersAdded) { // Calculate how many render tasks we have in total std::size_t numberOfRenderTasks = 0; - for (auto&& scene : mImpl->scenes ) + for(auto&& scene : mImpl->scenes) { - if ( scene && scene->taskList ) + if(scene && scene->taskList) { numberOfRenderTasks += scene->taskList->GetTasks().Count(); } } - std::size_t numberOfRenderInstructions = 0; - for ( auto&& scene : mImpl->scenes ) + for(auto&& scene : mImpl->scenes) { - if ( scene && scene->root && scene->taskList && scene->scene ) + if(scene && scene->root && scene->taskList && scene->scene) { - scene->scene->GetRenderInstructions().ResetAndReserve( bufferIndex, - static_cast( scene->taskList->GetTasks().Count() ) ); - - keepRendererRendering |= mImpl->renderTaskProcessor.Process( bufferIndex, - *scene->taskList, - *scene->root, - scene->sortedLayerList, - scene->scene->GetRenderInstructions(), - renderToFboEnabled, - isRenderingToFbo ); - - numberOfRenderInstructions += scene->scene->GetRenderInstructions().Count( bufferIndex ); + scene->scene->GetRenderInstructions().ResetAndReserve(bufferIndex, + static_cast(scene->taskList->GetTasks().Count())); + + // If there are animations running, only add render instruction if at least one animation is currently active (i.e. not delayed) + // or the nodes are dirty + if(!isAnimationRunning || animationActive || mImpl->renderingRequired || (mImpl->nodeDirtyFlags & RenderableUpdateFlags)) + { + keepRendererRendering |= mImpl->renderTaskProcessor.Process(bufferIndex, + *scene->taskList, + *scene->root, + scene->sortedLayerList, + scene->scene->GetRenderInstructions(), + renderToFboEnabled, + isRenderingToFbo); + + scene->scene->SetSkipRendering(false); + } + else + { + scene->scene->SetSkipRendering(true); + } + + numberOfRenderInstructions += scene->scene->GetRenderInstructions().Count(bufferIndex); } } - DALI_LOG_INFO( gLogFilter, Debug::General, - "Update: numberOfRenderTasks(%d), Render Instructions(%d)\n", - numberOfRenderTasks, numberOfRenderInstructions ); + DALI_LOG_INFO(gLogFilter, Debug::General, "Update: numberOfRenderTasks(%d), Render Instructions(%d)\n", numberOfRenderTasks, numberOfRenderInstructions); } } - for ( auto&& scene : mImpl->scenes ) + if(!uploadOnly) { - if ( scene && scene->root && scene->taskList ) + for(auto&& scene : mImpl->scenes) { - RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks(); - - // check the countdown and notify - bool doRenderOnceNotify = false; - mImpl->renderTaskWaiting = false; - for ( auto&& renderTask : tasks ) + if(scene && scene->root && scene->taskList) { - renderTask->UpdateState(); + RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks(); - if( renderTask->IsWaitingToRender() && - renderTask->ReadyToRender( bufferIndex ) /*avoid updating forever when source actor is off-stage*/ ) + // check the countdown and notify + bool doRenderOnceNotify = false; + mImpl->renderTaskWaiting = false; + for(auto&& renderTask : tasks) { - mImpl->renderTaskWaiting = true; // keep update/render threads alive + renderTask->UpdateState(); + + if(renderTask->IsWaitingToRender() && + renderTask->ReadyToRender(bufferIndex) /*avoid updating forever when source actor is off-stage*/) + { + mImpl->renderTaskWaiting = true; // keep update/render threads alive + } + + if(renderTask->HasRendered()) + { + doRenderOnceNotify = true; + } } - if( renderTask->HasRendered() ) + if(doRenderOnceNotify) { - doRenderOnceNotify = true; + DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n"); + mImpl->notificationManager.QueueCompleteNotification(scene->taskList->GetCompleteNotificationInterface()); } } - - if( doRenderOnceNotify ) - { - DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n"); - mImpl->notificationManager.QueueCompleteNotification( scene->taskList->GetCompleteNotificationInterface() ); - } } } @@ -1049,9 +1095,9 @@ uint32_t UpdateManager::Update( float elapsedSeconds, mImpl->previousUpdateScene = updateScene; // Check whether further updates are required - uint32_t keepUpdating = KeepUpdatingCheck( elapsedSeconds ); + uint32_t keepUpdating = KeepUpdatingCheck(elapsedSeconds); - if( keepRendererRendering ) + if(keepRendererRendering) { keepUpdating |= KeepUpdating::STAGE_KEEP_RENDERING; @@ -1068,10 +1114,10 @@ uint32_t UpdateManager::Update( float elapsedSeconds, return keepUpdating; } -uint32_t UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const +uint32_t UpdateManager::KeepUpdatingCheck(float elapsedSeconds) const { // Update the duration set via Stage::KeepRendering() - if ( mImpl->keepRenderingSeconds > 0.0f ) + if(mImpl->keepRenderingSeconds > 0.0f) { mImpl->keepRenderingSeconds -= elapsedSeconds; } @@ -1085,19 +1131,19 @@ uint32_t UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const // No need to check for renderQueue as there is always a render after update and if that // render needs another update it will tell the adaptor to call update again - if ( ( mImpl->renderingBehavior == DevelStage::Rendering::CONTINUOUSLY ) || - ( mImpl->keepRenderingSeconds > 0.0f ) ) + if((mImpl->renderingBehavior == DevelStage::Rendering::CONTINUOUSLY) || + (mImpl->keepRenderingSeconds > 0.0f)) { keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING; } - if ( IsAnimationRunning() || - mImpl->animationFinishedDuringUpdate ) + if(IsAnimationRunning() || + mImpl->animationFinishedDuringUpdate) { keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING; } - if ( mImpl->renderTaskWaiting ) + if(mImpl->renderTaskWaiting) { keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC; } @@ -1105,45 +1151,37 @@ uint32_t UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const return keepUpdatingRequest; } -void UpdateManager::SetDefaultSurfaceRect( const Rect& rect ) +void UpdateManager::SurfaceReplaced(Scene* scene) { - mImpl->surfaceRectChanged = true; - - typedef MessageValue1< RenderManager, Rect > DerivedType; + using DerivedType = MessageValue1; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetDefaultSurfaceRect, rect ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::SurfaceReplaced, scene); } -void UpdateManager::SurfaceReplaced( Scene* scene ) +void UpdateManager::KeepRendering(float durationSeconds) { - typedef MessageValue1< RenderManager, Scene* > DerivedType; - - // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); - - // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SurfaceReplaced, scene ); + mImpl->keepRenderingSeconds = std::max(mImpl->keepRenderingSeconds, durationSeconds); } -void UpdateManager::KeepRendering( float durationSeconds ) +void UpdateManager::SetRenderingBehavior(DevelStage::Rendering renderingBehavior) { - mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds ); + mImpl->renderingBehavior = renderingBehavior; } -void UpdateManager::SetRenderingBehavior( DevelStage::Rendering renderingBehavior ) +void UpdateManager::RequestRendering() { - mImpl->renderingBehavior = renderingBehavior; + mImpl->renderingRequired = true; } -void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, const Layer* rootLayer ) +void UpdateManager::SetLayerDepths(const SortedLayerPointers& layers, const Layer* rootLayer) { - for ( auto&& scene : mImpl->scenes ) + for(auto&& scene : mImpl->scenes) { - if ( scene && scene->root == rootLayer ) + if(scene && scene->root == rootLayer) { scene->sortedLayerList = layers; break; @@ -1151,302 +1189,292 @@ void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, const Lay } } -void UpdateManager::SetDepthIndices( OwnerPointer< NodeDepths >& nodeDepths ) +void UpdateManager::SetDepthIndices(OwnerPointer& nodeDepths) { // note,this vector is already in depth order. It could be used as-is to // remove sorting in update algorithm. However, it lacks layer boundary markers. - for( auto&& iter : nodeDepths->nodeDepths ) + for(auto&& iter : nodeDepths->nodeDepths) { - iter.node->SetDepthIndex( iter.sortedDepth ); + iter.node->SetDepthIndex(iter.sortedDepth); } - for ( auto&& scene : mImpl->scenes ) + for(auto&& scene : mImpl->scenes) { - if ( scene ) + if(scene) { // Go through node hierarchy and rearrange siblings according to depth-index - SortSiblingNodesRecursively( *scene->root ); + SortSiblingNodesRecursively(*scene->root); } } } -bool UpdateManager::IsDefaultSurfaceRectChanged() -{ - bool surfaceRectChanged = mImpl->surfaceRectChanged; - - // Reset the flag - mImpl->surfaceRectChanged = false; - - return surfaceRectChanged; -} - -void UpdateManager::AddFrameCallback( OwnerPointer< FrameCallback >& frameCallback, const Node* rootNode ) +void UpdateManager::AddFrameCallback(OwnerPointer& frameCallback, const Node* rootNode) { - mImpl->GetFrameCallbackProcessor( *this ).AddFrameCallback( frameCallback, rootNode ); + mImpl->GetFrameCallbackProcessor(*this).AddFrameCallback(frameCallback, rootNode); } -void UpdateManager::RemoveFrameCallback( FrameCallbackInterface* frameCallback ) +void UpdateManager::RemoveFrameCallback(FrameCallbackInterface* frameCallback) { - mImpl->GetFrameCallbackProcessor( *this ).RemoveFrameCallback( frameCallback ); + mImpl->GetFrameCallbackProcessor(*this).RemoveFrameCallback(frameCallback); } -void UpdateManager::AddSampler( OwnerPointer< Render::Sampler >& sampler ) +void UpdateManager::AddSampler(OwnerPointer& sampler) { // Message has ownership of Sampler while in transit from update to render - typedef MessageValue1< RenderManager, OwnerPointer< Render::Sampler > > DerivedType; + using DerivedType = MessageValue1 >; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddSampler, sampler ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AddSampler, sampler); } -void UpdateManager::RemoveSampler( Render::Sampler* sampler ) +void UpdateManager::RemoveSampler(Render::Sampler* sampler) { - typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType; + using DerivedType = MessageValue1; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveSampler, sampler ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::RemoveSampler, sampler); } -void UpdateManager::SetFilterMode( Render::Sampler* sampler, uint32_t minFilterMode, uint32_t magFilterMode ) +void UpdateManager::SetFilterMode(Render::Sampler* sampler, uint32_t minFilterMode, uint32_t magFilterMode) { - typedef MessageValue3< RenderManager, Render::Sampler*, uint32_t, uint32_t > DerivedType; + using DerivedType = MessageValue3; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode); } -void UpdateManager::SetWrapMode( Render::Sampler* sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode ) +void UpdateManager::SetWrapMode(Render::Sampler* sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode) { - typedef MessageValue4< RenderManager, Render::Sampler*, uint32_t, uint32_t, uint32_t > DerivedType; + using DerivedType = MessageValue4; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode); } -void UpdateManager::AddVertexBuffer( OwnerPointer< Render::VertexBuffer >& vertexBuffer ) +void UpdateManager::AddVertexBuffer(OwnerPointer& vertexBuffer) { // Message has ownership of format while in transit from update -> render - typedef MessageValue1< RenderManager, OwnerPointer< Render::VertexBuffer > > DerivedType; + using DerivedType = MessageValue1 >; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddVertexBuffer, vertexBuffer ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AddVertexBuffer, vertexBuffer); } -void UpdateManager::RemoveVertexBuffer( Render::VertexBuffer* vertexBuffer ) +void UpdateManager::RemoveVertexBuffer(Render::VertexBuffer* vertexBuffer) { - typedef MessageValue1< RenderManager, Render::VertexBuffer* > DerivedType; + using DerivedType = MessageValue1; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveVertexBuffer, vertexBuffer ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::RemoveVertexBuffer, vertexBuffer); } -void UpdateManager::SetVertexBufferFormat( Render::VertexBuffer* vertexBuffer, OwnerPointer< Render::VertexBuffer::Format>& format ) +void UpdateManager::SetVertexBufferFormat(Render::VertexBuffer* vertexBuffer, OwnerPointer& format) { // Message has ownership of format while in transit from update -> render - typedef MessageValue2< RenderManager, Render::VertexBuffer*, OwnerPointer< Render::VertexBuffer::Format > > DerivedType; + using DerivedType = MessageValue2 >; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetVertexBufferFormat, vertexBuffer, format ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::SetVertexBufferFormat, vertexBuffer, format); } -void UpdateManager::SetVertexBufferData( Render::VertexBuffer* vertexBuffer, OwnerPointer< Vector >& data, uint32_t size ) +void UpdateManager::SetVertexBufferData(Render::VertexBuffer* vertexBuffer, OwnerPointer >& data, uint32_t size) { // Message has ownership of format while in transit from update -> render - typedef MessageValue3< RenderManager, Render::VertexBuffer*, OwnerPointer< Dali::Vector >, uint32_t > DerivedType; + using DerivedType = MessageValue3 >, uint32_t>; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetVertexBufferData, vertexBuffer, data, size ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::SetVertexBufferData, vertexBuffer, data, size); } -void UpdateManager::AddGeometry( OwnerPointer< Render::Geometry >& geometry ) +void UpdateManager::AddGeometry(OwnerPointer& geometry) { // Message has ownership of format while in transit from update -> render - typedef MessageValue1< RenderManager, OwnerPointer< Render::Geometry > > DerivedType; + using DerivedType = MessageValue1 >; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddGeometry, geometry ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AddGeometry, geometry); } -void UpdateManager::RemoveGeometry( Render::Geometry* geometry ) +void UpdateManager::RemoveGeometry(Render::Geometry* geometry) { - typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType; + using DerivedType = MessageValue1; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveGeometry, geometry ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::RemoveGeometry, geometry); } -void UpdateManager::SetGeometryType( Render::Geometry* geometry, uint32_t geometryType ) +void UpdateManager::SetGeometryType(Render::Geometry* geometry, uint32_t geometryType) { - typedef MessageValue2< RenderManager, Render::Geometry*, uint32_t > DerivedType; + using DerivedType = MessageValue2; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetGeometryType, geometry, geometryType ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::SetGeometryType, geometry, geometryType); } -void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector& indices ) +void UpdateManager::SetIndexBuffer(Render::Geometry* geometry, Dali::Vector& indices) { - typedef IndexBufferMessage< RenderManager > DerivedType; + using DerivedType = IndexBufferMessage; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, geometry, indices ); + new(slot) DerivedType(&mImpl->renderManager, geometry, indices); } -void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer ) +void UpdateManager::RemoveVertexBuffer(Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer) { - typedef MessageValue2< RenderManager, Render::Geometry*, Render::VertexBuffer* > DerivedType; + using DerivedType = MessageValue2; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveVertexBuffer, geometry, vertexBuffer ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::RemoveVertexBuffer, geometry, vertexBuffer); } -void UpdateManager::AttachVertexBuffer( Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer ) +void UpdateManager::AttachVertexBuffer(Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer) { - typedef MessageValue2< RenderManager, Render::Geometry*, Render::VertexBuffer* > DerivedType; + using DerivedType = MessageValue2; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AttachVertexBuffer, geometry, vertexBuffer ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AttachVertexBuffer, geometry, vertexBuffer); } -void UpdateManager::AddTexture( OwnerPointer< Render::Texture >& texture ) +void UpdateManager::AddTexture(OwnerPointer& texture) { // Message has ownership of Texture while in transit from update -> render - typedef MessageValue1< RenderManager, OwnerPointer< Render::Texture > > DerivedType; + using DerivedType = MessageValue1 >; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddTexture, texture ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AddTexture, texture); } -void UpdateManager::RemoveTexture( Render::Texture* texture) +void UpdateManager::RemoveTexture(Render::Texture* texture) { - typedef MessageValue1< RenderManager, Render::Texture* > DerivedType; + using DerivedType = MessageValue1; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveTexture, texture ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::RemoveTexture, texture); } -void UpdateManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params ) +void UpdateManager::UploadTexture(Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params) { - typedef MessageValue3< RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > DerivedType; + using DerivedType = MessageValue3; // Reserve some memory inside the message queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params); } -void UpdateManager::GenerateMipmaps( Render::Texture* texture ) +void UpdateManager::GenerateMipmaps(Render::Texture* texture) { - typedef MessageValue1< RenderManager, Render::Texture* > DerivedType; + using DerivedType = MessageValue1; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::GenerateMipmaps, texture ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::GenerateMipmaps, texture); } -void UpdateManager::AddFrameBuffer( OwnerPointer< Render::FrameBuffer >& frameBuffer ) +void UpdateManager::AddFrameBuffer(OwnerPointer& frameBuffer) { - typedef MessageValue1< RenderManager, OwnerPointer< Render::FrameBuffer > > DerivedType; + using DerivedType = MessageValue1 >; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddFrameBuffer, frameBuffer ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AddFrameBuffer, frameBuffer); } -void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer) +void UpdateManager::RemoveFrameBuffer(Render::FrameBuffer* frameBuffer) { - typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType; + using DerivedType = MessageValue1; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveFrameBuffer, frameBuffer ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::RemoveFrameBuffer, frameBuffer); } -void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer ) +void UpdateManager::AttachColorTextureToFrameBuffer(Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer) { - typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t > DerivedType; + using DerivedType = MessageValue4; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer); } -void UpdateManager::AttachDepthTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel ) +void UpdateManager::AttachDepthTextureToFrameBuffer(Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel) { - typedef MessageValue3< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t > DerivedType; + using DerivedType = MessageValue3; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AttachDepthTextureToFrameBuffer, frameBuffer, texture, mipmapLevel ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AttachDepthTextureToFrameBuffer, frameBuffer, texture, mipmapLevel); } -void UpdateManager::AttachDepthStencilTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel ) +void UpdateManager::AttachDepthStencilTextureToFrameBuffer(Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel) { - typedef MessageValue3< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t > DerivedType; + using DerivedType = MessageValue3; // Reserve some memory inside the render queue - uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType)); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AttachDepthStencilTextureToFrameBuffer, frameBuffer, texture, mipmapLevel ); + new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AttachDepthStencilTextureToFrameBuffer, frameBuffer, texture, mipmapLevel); } } // namespace SceneGraph