/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 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.
// INTERNAL INCLUDES
#include <dali/integration-api/core.h>
+#include <dali/internal/common/owner-key-container.h>
+
#include <dali/internal/event/animation/animation-playlist.h>
#include <dali/internal/event/common/notification-manager.h>
#include <dali/internal/event/common/property-notifier.h>
}
/**
- * 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
+ * Helper to Erase an object from std::vector using discard queue
+ * @param container to remove from
+ * @param object to remove
+ * @param discardQueue to put the object to
+ * @param updateBufferIndex to use
*/
-void SortSiblingNodesRecursively(Node& node)
+template<class Type>
+inline void EraseUsingDiscardQueue(OwnerKeyContainer<Type>& container, const MemoryPoolKey<Type>& key, DiscardQueue<MemoryPoolKey<Type>, OwnerKeyContainer<Type>>& discardQueue, BufferIndex updateBufferIndex)
{
- NodeContainer& container = node.GetChildren();
- std::sort(container.Begin(), container.End(), [](Node* a, Node* b)
- { return a->GetDepthIndex() < b->GetDepthIndex(); });
+ DALI_ASSERT_DEBUG(key && "INVALID Key not allowed");
- // Descend tree and sort as well
- for(auto&& iter : container)
+ for(auto iter = container.begin(), end = container.end(); iter != end; ++iter)
{
- SortSiblingNodesRecursively(*iter);
+ if(*iter == key)
+ {
+ // 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));
+ return; // return as we only ever remove one object. Iterators to container are now invalidated as well so cannot continue
+ }
}
}
{
}
- ~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
OwnerContainer<NodeResetter*> nodeResetters; ///< A container of node 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
+ OwnerKeyContainer<Renderer> renderers; ///< A container of owned renderers
OwnerContainer<TextureSet*> textureSets; ///< A container of owned texture sets
OwnerContainer<Shader*> shaders; ///< A container of owned shaders
- DiscardQueue<Node*, OwnerContainer<Node*>> nodeDiscardQueue; ///< Nodes are added here when disconnected from the scene-graph.
- DiscardQueue<Shader*, OwnerContainer<Shader*>> shaderDiscardQueue;
- DiscardQueue<Renderer*, OwnerContainer<Renderer*>> rendererDiscardQueue;
- DiscardQueue<Scene*, OwnerContainer<Scene*>> sceneDiscardQueue;
+ DiscardQueue<Node*, OwnerContainer<Node*>> nodeDiscardQueue; ///< Nodes are added here when disconnected from the scene-graph.
+ DiscardQueue<Shader*, OwnerContainer<Shader*>> shaderDiscardQueue;
+ DiscardQueue<MemoryPoolKey<Renderer>, OwnerKeyContainer<Renderer>> rendererDiscardQueue;
+ DiscardQueue<Scene*, OwnerContainer<Scene*>> sceneDiscardQueue;
OwnerPointer<PanGesture> panGestureProcessor; ///< Owned pan gesture processor; it lives for the lifecycle of UpdateManager
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() &&
+ 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);
mImpl->shaderSaver = &upstream;
}
-void UpdateManager::AddRenderer(OwnerPointer<Renderer>& renderer)
+void UpdateManager::AddRenderer(const RendererKey& rendererKey)
{
- DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] AddRenderer\n", renderer.Get());
+ SceneGraph::Renderer* renderer = rendererKey.Get();
+
+ DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] AddRenderer\n", renderer);
renderer->ConnectToSceneGraph(*mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex());
- mImpl->renderers.PushBack(renderer.Release());
+ mImpl->renderers.PushBack(rendererKey);
}
-void UpdateManager::RemoveRenderer(Renderer* renderer)
+void UpdateManager::RemoveRenderer(const RendererKey& rendererKey)
{
- DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] RemoveRenderer\n", renderer);
+ DALI_LOG_INFO(gLogFilter, Debug::General, "[%x] RemoveRenderer\n", rendererKey.Get());
// Find the renderer and destroy it
- EraseUsingDiscardQueue(mImpl->renderers, renderer, mImpl->rendererDiscardQueue, mSceneGraphBuffers.GetUpdateBufferIndex());
+ EraseUsingDiscardQueue(mImpl->renderers, rendererKey, mImpl->rendererDiscardQueue, mSceneGraphBuffers.GetUpdateBufferIndex());
// Need to remove the render object as well
- renderer->DisconnectFromSceneGraph(*mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex());
+ rendererKey->DisconnectFromSceneGraph(*mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex());
}
void UpdateManager::AttachRenderer(Node* node, Renderer* renderer)
{
- node->AddRenderer(renderer);
+ node->AddRenderer(Renderer::GetKey(renderer));
mImpl->renderersAdded = true;
}
void UpdateManager::UpdateRenderers(BufferIndex bufferIndex)
{
- for(auto&& renderer : mImpl->renderers)
+ for(const auto& rendererKey : mImpl->renderers)
{
// Apply constraints
+ auto renderer = rendererKey.Get();
ConstrainPropertyOwner(*renderer, bufferIndex);
mImpl->renderingRequired = renderer->PrepareRender(bufferIndex) || mImpl->renderingRequired;
void UpdateManager::SetDepthIndices(OwnerPointer<NodeDepths>& 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)
- {
- iter.node->SetDepthIndex(iter.sortedDepth);
- }
-
- for(auto&& scene : mImpl->scenes)
+ // note, this vector is already in depth order.
+ // So if we reverse iterate, we can assume that
+ // my descendant node's depth index are updated.
+ for(auto rIter = nodeDepths->nodeDepths.rbegin(), rEndIter = nodeDepths->nodeDepths.rend(); rIter != rEndIter; rIter++)
{
- if(scene)
+ auto* node = rIter->node;
+ node->SetDepthIndex(rIter->sortedDepth);
+ if(node->IsChildrenReorderRequired())
{
- // Go through node hierarchy and rearrange siblings according to depth-index
- SortSiblingNodesRecursively(*scene->root);
+ // Reorder children container only if sibiling order changed.
+ NodeContainer& container = node->GetChildren();
+ std::sort(container.Begin(), container.End(), [](Node* a, Node* b) { return a->GetDepthIndex() < b->GetDepthIndex(); });
}
}
}
new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AttachVertexBuffer, geometry, vertexBuffer);
}
-void UpdateManager::AddTexture(OwnerPointer<Render::Texture>& texture)
+void UpdateManager::AddTexture(const Render::TextureKey& texture)
{
- // Message has ownership of Texture while in transit from update -> render
- using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::Texture>>;
+ using DerivedType = MessageValue1<RenderManager, Render::TextureKey>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType));
new(slot) DerivedType(&mImpl->renderManager, &RenderManager::AddTexture, texture);
}
-void UpdateManager::RemoveTexture(Render::Texture* texture)
+void UpdateManager::RemoveTexture(const Render::TextureKey& texture)
{
- using DerivedType = MessageValue1<RenderManager, Render::Texture*>;
+ using DerivedType = MessageValue1<RenderManager, Render::TextureKey>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType));
new(slot) DerivedType(&mImpl->renderManager, &RenderManager::RemoveTexture, texture);
}
-void UpdateManager::UploadTexture(Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params)
+void UpdateManager::UploadTexture(const Render::TextureKey& texture, PixelDataPtr pixelData, const Texture::UploadParams& params)
{
- using DerivedType = MessageValue3<RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams>;
+ using DerivedType = MessageValue3<RenderManager, Render::TextureKey, PixelDataPtr, Texture::UploadParams>;
// Reserve some memory inside the message queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType));
new(slot) DerivedType(&mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params);
}
-void UpdateManager::GenerateMipmaps(Render::Texture* texture)
+void UpdateManager::GenerateMipmaps(const Render::TextureKey& texture)
{
- using DerivedType = MessageValue1<RenderManager, Render::Texture*>;
+ using DerivedType = MessageValue1<RenderManager, Render::TextureKey>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType));
projects / platform / core / uifw / dali-core.git / blobdiff