From: jmm Date: Thu, 15 May 2025 07:50:48 +0000 (+0900) Subject: Allow multiple cache renderers(as RenderContainer) X-Git-Tag: dali_2.4.23~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F04%2F324304%2F5;p=platform%2Fcore%2Fuifw%2Fdali-core.git Allow multiple cache renderers(as RenderContainer) Change-Id: Ic8495c768c0308fb2cb955dfc9690f7d15de0578 Signed-off-by: jmm --- diff --git a/automated-tests/src/dali/utc-Dali-CustomActor.cpp b/automated-tests/src/dali/utc-Dali-CustomActor.cpp index b2fc0c84a..70c83e0dc 100644 --- a/automated-tests/src/dali/utc-Dali-CustomActor.cpp +++ b/automated-tests/src/dali/utc-Dali-CustomActor.cpp @@ -2237,6 +2237,7 @@ int UtcDaliCustomActorImplSetRemoveCacheRenderer(void) DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 1, TEST_LOCATION); DerivedCustomActor customActor = DerivedCustomActor::New(); + application.GetScene().Add(customActor); Geometry geometry = CreateQuadGeometry(); Shader shader = CreateShader(); @@ -2244,23 +2245,54 @@ int UtcDaliCustomActorImplSetRemoveCacheRenderer(void) Renderer renderer2 = Renderer::New(geometry, shader); customActor.AddRenderer(renderer); - customActor.GetImplementation().SetCacheRenderer(renderer); - customActor.GetImplementation().SetCacheRenderer(renderer2); - customActor.GetImplementation().SetCacheRenderer(renderer2); - DALI_TEST_EQUALS(customActor.GetRendererCount(), 1, TEST_LOCATION); // cache renderer is not counted. + customActor.AddCacheRenderer(renderer); + customActor.AddCacheRenderer(renderer2); + customActor.AddCacheRenderer(renderer2); + DALI_TEST_EQUALS(customActor.GetRendererCount(), 1, TEST_LOCATION); + DALI_TEST_EQUALS(customActor.GetCacheRendererCount(), 2, TEST_LOCATION); customActor.RemoveRenderer(0u); - customActor.GetImplementation().SetCacheRenderer(renderer); + customActor.AddCacheRenderer(renderer); application.SendNotification(); application.Render(); - customActor.GetImplementation().RemoveCacheRenderer(); - customActor.GetImplementation().RemoveCacheRenderer(); + DALI_TEST_EQUALS(customActor.GetRendererCount(), 0, TEST_LOCATION); + DALI_TEST_EQUALS(customActor.GetCacheRendererCount(), 2, TEST_LOCATION); + + customActor.RemoveCacheRenderer(renderer); + customActor.RemoveCacheRenderer(renderer2); application.SendNotification(); application.Render(); - customActor.GetImplementation().SetCacheRenderer(renderer2); + DALI_TEST_EQUALS(customActor.GetCacheRendererCount(), 0, TEST_LOCATION); + + customActor.AddCacheRenderer(renderer2); + + CameraActor camera = CameraActor::New(); + application.GetScene().Add(camera); + + RenderTaskList taskList = application.GetScene().GetRenderTaskList(); + RenderTask newTask = taskList.CreateTask(); + newTask.SetSourceActor(customActor); + newTask.SetExclusive(true); + newTask.SetCameraActor(camera); + newTask.SetInputEnabled(false); + newTask.SetClearColor(Color::TRANSPARENT); + newTask.SetClearEnabled(true); + newTask.SetFrameBuffer(FrameBuffer::New(10u, 10u)); + + RenderTask newTask2 = taskList.CreateTask(); + newTask2.SetSourceActor(customActor); + newTask2.SetExclusive(true); + newTask2.SetCameraActor(camera); + newTask2.SetInputEnabled(false); + newTask2.SetClearColor(Color::TRANSPARENT); + newTask2.SetClearEnabled(true); + newTask2.SetFrameBuffer(FrameBuffer::New(10u, 10u)); + + application.SendNotification(); + application.Render(); tet_result(TET_PASS); END_TEST; diff --git a/automated-tests/src/dali/utc-Dali-RenderTask.cpp b/automated-tests/src/dali/utc-Dali-RenderTask.cpp index 401ffbfd4..28e5acfe7 100644 --- a/automated-tests/src/dali/utc-Dali-RenderTask.cpp +++ b/automated-tests/src/dali/utc-Dali-RenderTask.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * Copyright (c) 2025 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. @@ -5335,9 +5335,9 @@ int UtcDaliRenderTaskKeepRenderResult(void) rootActor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f)); application.GetScene().Add(rootActor); - RenderTaskList taskList = application.GetScene().GetRenderTaskList(); - Texture frameBufferTexture = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 10, 10); - FrameBuffer frameBuffer = FrameBuffer::New(frameBufferTexture.GetWidth(), frameBufferTexture.GetHeight()); + RenderTaskList taskList = application.GetScene().GetRenderTaskList(); + Texture frameBufferTexture = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 10, 10); + FrameBuffer frameBuffer = FrameBuffer::New(frameBufferTexture.GetWidth(), frameBufferTexture.GetHeight()); frameBuffer.AttachColorTexture(frameBufferTexture); RenderTask newTask = taskList.CreateTask(); diff --git a/dali/internal/event/actors/actor-impl.cpp b/dali/internal/event/actors/actor-impl.cpp index a391a5611..635b5a851 100644 --- a/dali/internal/event/actors/actor-impl.cpp +++ b/dali/internal/event/actors/actor-impl.cpp @@ -932,7 +932,7 @@ uint32_t Actor::AddRenderer(Renderer& renderer) { if(!mRenderers) { - mRenderers = new RendererContainer(GetEventThreadServices()); + mRenderers = new RendererContainer(GetEventThreadServices(), false); } return mRenderers->Add(GetNode(), renderer, mIsBlendEquationSet, mBlendEquation); } @@ -974,6 +974,10 @@ void Actor::SetBlendEquation(DevelBlendEquation::Type blendEquation) { mRenderers->SetBlending(blendEquation); } + if(mCacheRenderers) + { + mCacheRenderers->SetBlending(blendEquation); + } } mIsBlendEquationSet = true; } @@ -1180,34 +1184,27 @@ void Actor::RequestRenderTaskReorder() } } -void Actor::SetCacheRenderer(Renderer& renderer) +uint32_t Actor::AddCacheRenderer(Renderer& renderer) { const SceneGraph::Node& node = GetNode(); - if(mCacheRenderer) + if(!mCacheRenderers) { - if(mCacheRenderer == RendererPtr(&renderer)) - { - return; - } - RemoveCacheRenderer(); + mCacheRenderers = new RendererContainer(GetEventThreadServices(), true); } + return mCacheRenderers->Add(node, renderer, mIsBlendEquationSet, mBlendEquation); +} - if(mIsBlendEquationSet) - { - renderer.SetBlendEquation(mBlendEquation); - } - mCacheRenderer = RendererPtr(&renderer); - AttachCacheRendererMessage(GetEventThreadServices().GetUpdateManager(), node, renderer.GetRendererSceneObject()); +uint32_t Actor::GetCacheRendererCount() const +{ + return mCacheRenderers ? mCacheRenderers->GetCount() : 0u; } -void Actor::RemoveCacheRenderer() +void Actor::RemoveCacheRenderer(Renderer& renderer) { - if(DALI_LIKELY(mCacheRenderer)) + if(mCacheRenderers) { - const SceneGraph::Node& node = GetNode(); - DetachCacheRendererMessage(GetEventThreadServices(), node, mCacheRenderer->GetRendererSceneObject()); - mCacheRenderer.Reset(); + mCacheRenderers->Remove(GetNode(), renderer); } } @@ -1218,6 +1215,7 @@ Actor::Actor(DerivedType derivedType, const SceneGraph::Node& node) mParent(nullptr), mScene(nullptr), mRenderers(nullptr), + mCacheRenderers(nullptr), mParentOrigin(nullptr), mAnchorPoint(nullptr), mGestureData(nullptr), @@ -1302,9 +1300,9 @@ Actor::~Actor() // Detach all renderers before delete container. mRenderers->RemoveAll(GetNode()); } - if(mCacheRenderer) + if(mCacheRenderers) { - RemoveCacheRenderer(); + mCacheRenderers->RemoveAll(GetNode()); } // Root layer will destroy its node in its own destructor @@ -1317,6 +1315,7 @@ Actor::~Actor() } // Cleanup renderer list delete mRenderers; + delete mCacheRenderers; // Cleanup optional gesture data delete mGestureData; diff --git a/dali/internal/event/actors/actor-impl.h b/dali/internal/event/actors/actor-impl.h index 1743c3c06..2976d7cf3 100644 --- a/dali/internal/event/actors/actor-impl.h +++ b/dali/internal/event/actors/actor-impl.h @@ -1659,12 +1659,19 @@ public: * @param[in] renderer Renderer to set to the Actor * @pre The renderer must be initialized. */ - void SetCacheRenderer(Renderer& renderer); + uint32_t AddCacheRenderer(Renderer& renderer); + + /** + * Retrieves the number of cache renderers in this actor. + * @return The number of cache renderers. + */ + uint32_t GetCacheRendererCount() const; /** * @brief Removes cache renderer from the Actor. + * @param[in] renderer The cache renderer to remove. */ - void RemoveCacheRenderer(); + void RemoveCacheRenderer(Renderer& renderer); protected: enum DerivedType @@ -2048,15 +2055,15 @@ private: void SetUpdateAreaHint(const Vector4& updateAreaHint); protected: - ActorParentImpl mParentImpl; ///< Implementation of ActorParent; - ActorSizer mSizer; ///< Implementation for managing actor size - ActorParent* mParent; ///< Each actor (except the root) can have one parent - Scene* mScene; ///< The scene the actor is added to - RendererContainer* mRenderers; ///< Renderer container - RendererPtr mCacheRenderer; ///< Result of offscreen rendering - Vector3* mParentOrigin; ///< NULL means ParentOrigin::DEFAULT. ParentOrigin is non-animatable - Vector3* mAnchorPoint; ///< NULL means AnchorPoint::DEFAULT. AnchorPoint is non-animatable - ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures + ActorParentImpl mParentImpl; ///< Implementation of ActorParent; + ActorSizer mSizer; ///< Implementation for managing actor size + ActorParent* mParent; ///< Each actor (except the root) can have one parent + Scene* mScene; ///< The scene the actor is added to + RendererContainer* mRenderers; ///< Renderer container + RendererContainer* mCacheRenderers; ///< Renderers rendering offscreen rendering results + Vector3* mParentOrigin; ///< NULL means ParentOrigin::DEFAULT. ParentOrigin is non-animatable + Vector3* mAnchorPoint; ///< NULL means AnchorPoint::DEFAULT. AnchorPoint is non-animatable + ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures // Signals Dali::Actor::TouchEventSignalType mInterceptTouchedSignal; diff --git a/dali/internal/event/actors/actor-renderer-container.cpp b/dali/internal/event/actors/actor-renderer-container.cpp index cc2742359..30cba7757 100644 --- a/dali/internal/event/actors/actor-renderer-container.cpp +++ b/dali/internal/event/actors/actor-renderer-container.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * Copyright (c) 2025 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. @@ -19,8 +19,9 @@ namespace Dali::Internal { -RendererContainer::RendererContainer(EventThreadServices& eventThreadServices) -: EventThreadServicesHolder(eventThreadServices) +RendererContainer::RendererContainer(EventThreadServices& eventThreadServices, bool isCache) +: EventThreadServicesHolder(eventThreadServices), + mIsCache(isCache) { } @@ -44,7 +45,16 @@ uint32_t RendererContainer::Add(const SceneGraph::Node& node, Renderer& renderer } RendererPtr rendererPtr = RendererPtr(&renderer); mRenderers.push_back(rendererPtr); - AttachRendererMessage(GetEventThreadServices().GetUpdateManager(), node, renderer.GetRendererSceneObject()); + + if(mIsCache) + { + AttachCacheRendererMessage(GetEventThreadServices().GetUpdateManager(), node, renderer.GetRendererSceneObject()); + } + else + { + AttachRendererMessage(GetEventThreadServices().GetUpdateManager(), node, renderer.GetRendererSceneObject()); + } + return index; } @@ -56,7 +66,15 @@ void RendererContainer::Remove(const SceneGraph::Node& node, Renderer& renderer) if((*iter).Get() == &renderer) { mRenderers.erase(iter); - DetachRendererMessage(GetEventThreadServices(), node, renderer.GetRendererSceneObject()); + + if(mIsCache) + { + DetachCacheRendererMessage(GetEventThreadServices(), node, renderer.GetRendererSceneObject()); + } + else + { + DetachRendererMessage(GetEventThreadServices(), node, renderer.GetRendererSceneObject()); + } break; } } @@ -67,16 +85,35 @@ void RendererContainer::Remove(const SceneGraph::Node& node, uint32_t index) if(index < mRenderers.size()) { RendererPtr renderer = mRenderers[index]; - DetachRendererMessage(GetEventThreadServices(), node, renderer->GetRendererSceneObject()); + + if(mIsCache) + { + DetachCacheRendererMessage(GetEventThreadServices(), node, renderer->GetRendererSceneObject()); + } + else + { + DetachRendererMessage(GetEventThreadServices(), node, renderer->GetRendererSceneObject()); + } + mRenderers.erase(mRenderers.begin() + index); } } void RendererContainer::RemoveAll(const SceneGraph::Node& node) { - for(auto&& renderer : mRenderers) + if(mIsCache) { - DetachRendererMessage(GetEventThreadServices(), node, renderer->GetRendererSceneObject()); + for(auto&& renderer : mRenderers) + { + DetachCacheRendererMessage(GetEventThreadServices(), node, renderer->GetRendererSceneObject()); + } + } + else + { + for(auto&& renderer : mRenderers) + { + DetachRendererMessage(GetEventThreadServices(), node, renderer->GetRendererSceneObject()); + } } mRenderers.clear(); } diff --git a/dali/internal/event/actors/actor-renderer-container.h b/dali/internal/event/actors/actor-renderer-container.h index 1e61c39f6..ba05d91ad 100644 --- a/dali/internal/event/actors/actor-renderer-container.h +++ b/dali/internal/event/actors/actor-renderer-container.h @@ -2,7 +2,7 @@ #define DALI_INTERNAL_ACTORS_ACTOR_RENDERER_CONTAINER_H /* - * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * Copyright (c) 2025 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. @@ -43,8 +43,9 @@ public: * Constructor. * * @param[in] eventThreadServices - thread services for sending messages + * @param[in] isCache - whether the container is for cache renderers(drawing offscreen rendering results) */ - RendererContainer(EventThreadServices& eventThreadServices); + RendererContainer(EventThreadServices& eventThreadServices, bool isCache); /** * Add a renderer to this actor & actor's node, with blending applied if necessary. @@ -103,6 +104,8 @@ public: private: std::vector mRenderers; ///< The contained renderers + + bool mIsCache : 1; /// The container is for cache renderers }; } // namespace Dali::Internal diff --git a/dali/internal/update/manager/render-task-processor.cpp b/dali/internal/update/manager/render-task-processor.cpp index 462c5f05d..f5b7a9fd0 100644 --- a/dali/internal/update/manager/render-task-processor.cpp +++ b/dali/internal/update/manager/render-task-processor.cpp @@ -114,12 +114,12 @@ void AddRenderablesForTask(BufferIndex updateBufferIndex, node.SetUpdated(true); } - RendererKey cacheRenderer = node.GetCacheRenderer(); - const bool isNodeExclusiveAtAnotherRenderTask = node.GetExclusiveRenderTaskCount() && !node.IsExclusiveRenderTask(&renderTask); + const uint32_t cacheCount = node.GetCacheRendererCount(); + const bool isNodeExclusiveAtAnotherRenderTask = node.GetExclusiveRenderTaskCount() && !node.IsExclusiveRenderTask(&renderTask); // Check whether node is exclusive to a different render-task // Check if node has pre-drawn cache to draw - if(isNodeExclusiveAtAnotherRenderTask && !cacheRenderer) + if(isNodeExclusiveAtAnotherRenderTask && cacheCount == 0u) { return; } @@ -170,9 +170,13 @@ void AddRenderablesForTask(BufferIndex updateBufferIndex, RenderableContainer& target = DALI_LIKELY(inheritedDrawMode == DrawMode::NORMAL) ? layer->colorRenderables : layer->overlayRenderables; - if(isNodeExclusiveAtAnotherRenderTask && cacheRenderer) + if(isNodeExclusiveAtAnotherRenderTask && cacheCount) { - target.PushBack(Renderable(&node, cacheRenderer)); + for(uint32_t i = 0; i < cacheCount; ++i) + { + SceneGraph::RendererKey rendererKey = node.GetCacheRendererAt(i); + target.PushBack(Renderable(&node, rendererKey)); + } return; } diff --git a/dali/internal/update/manager/update-manager.cpp b/dali/internal/update/manager/update-manager.cpp index a1fe66904..7d74e5bad 100644 --- a/dali/internal/update/manager/update-manager.cpp +++ b/dali/internal/update/manager/update-manager.cpp @@ -855,7 +855,7 @@ void UpdateManager::AttachRenderer(Node* node, Renderer* renderer) void UpdateManager::AttachCacheRenderer(Node* node, Renderer* renderer) { - node->SetCacheRenderer(Renderer::GetKey(renderer)); + node->AddCacheRenderer(Renderer::GetKey(renderer)); mImpl->renderersAdded = true; } diff --git a/dali/internal/update/nodes/node.cpp b/dali/internal/update/nodes/node.cpp index 010f499f5..11e2e0787 100644 --- a/dali/internal/update/nodes/node.cpp +++ b/dali/internal/update/nodes/node.cpp @@ -265,23 +265,34 @@ void Node::RemoveRenderer(const RendererKey& renderer) } } -void Node::SetCacheRenderer(const RendererKey& renderer) +void Node::AddCacheRenderer(const RendererKey& renderer) { - if(DALI_UNLIKELY(mCacheRenderer)) + for(auto&& existingRenderer : mCacheRenderers) { - mCacheRenderer->DetachFromNodeDataProvider(*this); + if(existingRenderer == renderer) + { + return; + } } + SetUpdated(true); - mCacheRenderer = renderer; + + mCacheRenderers.PushBack(renderer); } -void Node::RemoveCacheRenderer() +void Node::RemoveCacheRenderer(const RendererKey& renderer) { - if(DALI_LIKELY(mCacheRenderer)) + RendererContainer::SizeType rendererCount(mCacheRenderers.Size()); + for(RendererContainer::SizeType i = 0; i < rendererCount; ++i) { - mCacheRenderer->DetachFromNodeDataProvider(*this); - SetUpdated(true); - mCacheRenderer = RendererKey{}; + if(mCacheRenderers[i] == renderer) + { + renderer->DetachFromNodeDataProvider(*this); + + SetUpdated(true); + mCacheRenderers.Erase(mCacheRenderers.Begin() + i); + return; + } } } diff --git a/dali/internal/update/nodes/node.h b/dali/internal/update/nodes/node.h index 94bbe7988..11f4fca62 100644 --- a/dali/internal/update/nodes/node.h +++ b/dali/internal/update/nodes/node.h @@ -268,22 +268,32 @@ public: } /** - * Set cache renderer which draws output of offscreen rendering - * Draws only when mOffScreenRendering is true + * Add cache renderer which draws output of offscreen rendering */ - void SetCacheRenderer(const RendererKey& renderer); + void AddCacheRenderer(const RendererKey& renderer); /** * Remove cache renderer */ - void RemoveCacheRenderer(); + void RemoveCacheRenderer(const RendererKey& renderer); /** * Get cache renderer + * @param[in] index The index of the renderer in the node's cache renderer container + * @return RendererKey of cache renderer with given index */ - RendererKey GetCacheRenderer() const + RendererKey GetCacheRendererAt(uint32_t index) const { - return mCacheRenderer; + return mCacheRenderers[index]; + } + + /** + * Retrieve the number of cache renderes for the node. + * @return The size of cache renderer container + */ + uint32_t GetCacheRendererCount() const + { + return static_cast(mCacheRenderers.Size()); } // Containment methods @@ -1177,8 +1187,8 @@ protected: Node* mParent; ///< Pointer to parent node (a child is owned by its parent) RenderTaskContainer mExclusiveRenderTasks; ///< Nodes can be marked as exclusive to multiple RenderTasks - RendererContainer mRenderers; ///< Container of renderers; not owned - RendererKey mCacheRenderer; ///< Result of offscreen rendering + RendererContainer mRenderers; ///< Container of renderers; not owned + RendererContainer mCacheRenderers; ///< Container of renderers drawing offscreen rendering results NodeContainer mChildren; ///< Container of children; not owned @@ -1308,13 +1318,13 @@ inline void DetachRendererMessage(EventThreadServices& eventThreadServices, cons inline void DetachCacheRendererMessage(EventThreadServices& eventThreadServices, const Node& node, const Renderer& renderer) { - using LocalType = Message; + using LocalType = MessageValue1; // Reserve some memory inside the message queue uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType)); // Construct message in the message queue memory; note that delete should not be called on the return value - new(slot) LocalType(&node, &Node::RemoveCacheRenderer); + new(slot) LocalType(&node, &Node::RemoveCacheRenderer, Renderer::GetKey(renderer)); } inline void SetDepthIndexMessage(EventThreadServices& eventThreadServices, const Node& node, uint32_t depthIndex) diff --git a/dali/public-api/actors/actor.cpp b/dali/public-api/actors/actor.cpp index 65a2fdc44..44d931c02 100644 --- a/dali/public-api/actors/actor.cpp +++ b/dali/public-api/actors/actor.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * Copyright (c) 2025 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. @@ -260,6 +260,21 @@ void Actor::RemoveRenderer(uint32_t index) GetImplementation(*this).RemoveRenderer(index); } +uint32_t Actor::AddCacheRenderer(Renderer& renderer) +{ + return GetImplementation(*this).AddCacheRenderer(GetImplementation(renderer)); +} + +uint32_t Actor::GetCacheRendererCount() const +{ + return GetImplementation(*this).GetCacheRendererCount(); +} + +void Actor::RemoveCacheRenderer(Renderer& renderer) +{ + GetImplementation(*this).RemoveCacheRenderer(GetImplementation(renderer)); +} + Actor::OnRelayoutSignalType& Actor::OnRelayoutSignal() { return GetImplementation(*this).OnRelayoutSignal(); diff --git a/dali/public-api/actors/actor.h b/dali/public-api/actors/actor.h index 75c2d1771..49a161f49 100644 --- a/dali/public-api/actors/actor.h +++ b/dali/public-api/actors/actor.h @@ -2,7 +2,7 @@ #define DALI_ACTOR_H /* - * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * Copyright (c) 2025 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. @@ -1192,6 +1192,29 @@ public: // Renderer */ void RemoveRenderer(uint32_t index); + /** + * @brief Add renderer drawing cached output to this Actor. + * @SINCE_2_3.54 + * @param[in] renderer Renderer to set to the Actor + * @return The index of the Renderer that was added + * @pre The renderer must be initialized. + */ + uint32_t AddCacheRenderer(Renderer& renderer); + + /** + * @brief Get total number of cache renderers. + * @SINCE_2_4.19 + * @return The size of cache renderer container + */ + uint32_t GetCacheRendererCount() const; + + /** + * @brief Removes cache renderer from the Actor. + * @param[in] renderer Renderer to erase. + * @SINCE_2_3.54 + */ + void RemoveCacheRenderer(Renderer& renderer); + public: // Signals /** * @brief This signal is emitted when touch input is received. diff --git a/dali/public-api/actors/custom-actor-impl.cpp b/dali/public-api/actors/custom-actor-impl.cpp index 702f9f86f..25a2481ca 100644 --- a/dali/public-api/actors/custom-actor-impl.cpp +++ b/dali/public-api/actors/custom-actor-impl.cpp @@ -59,16 +59,6 @@ void CustomActorImpl::RequestRenderTaskReorder() mOwner->RequestRenderTaskReorder(); } -void CustomActorImpl::SetCacheRenderer(Renderer& renderer) -{ - mOwner->SetCacheRenderer(GetImplementation(renderer)); -} - -void CustomActorImpl::RemoveCacheRenderer() -{ - mOwner->RemoveCacheRenderer(); -} - CustomActorImpl::CustomActorImpl(ActorFlags flags) : mOwner(nullptr), mFlags(flags) diff --git a/dali/public-api/actors/custom-actor-impl.h b/dali/public-api/actors/custom-actor-impl.h index 02e3396c6..5970a0f8d 100644 --- a/dali/public-api/actors/custom-actor-impl.h +++ b/dali/public-api/actors/custom-actor-impl.h @@ -239,20 +239,6 @@ public: */ void RequestRenderTaskReorder(); - /** - * @brief Set renderer drawing cached output to this Actor. - * @SINCE_2_3.54 - * @param[in] renderer Renderer to set to the Actor - * @pre The renderer must be initialized. - */ - void SetCacheRenderer(Renderer& renderer); - - /** - * @brief Removes cache renderer from the Actor. - * @SINCE_2_3.54 - */ - void RemoveCacheRenderer(); - /** * @brief Called after the size negotiation has been finished for this control. *