Refactored out actor render container

Change-Id: Ib7f45346b92d7c9674833da5c6b54e889e8da28f

diff --git a/dali/internal/event/actors/actor-impl.cpp b/dali/internal/event/actors/actor-impl.cpp
index decf85a..99d47f1 100644 (file)
--- a/dali/internal/event/actors/actor-impl.cpp
+++ b/dali/internal/event/actors/actor-impl.cpp
@@ -975,67 +975,34 @@ uint32_t Actor::AddRenderer(Renderer& renderer)
 {
   if(!mRenderers)
   {
-    mRenderers = new RendererContainer;
+    mRenderers = new RendererContainer(GetEventThreadServices());
   }
-
-  if(mIsBlendEquationSet)
-  {
-    renderer.SetBlendEquation(static_cast<DevelBlendEquation::Type>(mBlendEquation));
-  }
-
-  uint32_t    index       = static_cast<uint32_t>(mRenderers->size()); //  4,294,967,295 renderers per actor
-  RendererPtr rendererPtr = RendererPtr(&renderer);
-  mRenderers->push_back(rendererPtr);
-  AttachRendererMessage(GetEventThreadServices().GetUpdateManager(), GetNode(), renderer.GetRendererSceneObject());
-  return index;
+  return mRenderers->Add(GetNode(), renderer, mIsBlendEquationSet, mBlendEquation);
 }
 
 uint32_t Actor::GetRendererCount() const
 {
-  uint32_t rendererCount(0);
-  if(mRenderers)
-  {
-    rendererCount = static_cast<uint32_t>(mRenderers->size()); //  4,294,967,295 renderers per actor
-  }
-
-  return rendererCount;
+  return mRenderers ? mRenderers->GetCount() : 0u;
 }
 
 RendererPtr Actor::GetRendererAt(uint32_t index)
 {
-  RendererPtr renderer;
-  if(index < GetRendererCount())
-  {
-    renderer = (*mRenderers)[index];
-  }
-
-  return renderer;
+  return mRenderers ? mRenderers->GetRendererAt(index) : nullptr;
 }
 
 void Actor::RemoveRenderer(Renderer& renderer)
 {
   if(mRenderers)
   {
-    RendererIter end = mRenderers->end();
-    for(RendererIter iter = mRenderers->begin(); iter != end; ++iter)
-    {
-      if((*iter).Get() == &renderer)
-      {
-        mRenderers->erase(iter);
-        DetachRendererMessage(GetEventThreadServices(), GetNode(), renderer.GetRendererSceneObject());
-        break;
-      }
-    }
+    mRenderers->Remove(GetNode(), renderer);
   }
 }
 
 void Actor::RemoveRenderer(uint32_t index)
 {
-  if(index < GetRendererCount())
+  if(mRenderers)
   {
-    RendererPtr renderer = (*mRenderers)[index];
-    DetachRendererMessage(GetEventThreadServices(), GetNode(), renderer.Get()->GetRendererSceneObject());
-    mRenderers->erase(mRenderers->begin() + index);
+    mRenderers->Remove(GetNode(), index);
   }
 }
 
@@ -1045,12 +1012,10 @@ void Actor::SetBlendEquation(DevelBlendEquation::Type blendEquation)
   {
     if(mBlendEquation != blendEquation)
     {
-      mBlendEquation         = blendEquation;
-      uint32_t rendererCount = GetRendererCount();
-      for(uint32_t i = 0; i < rendererCount; ++i)
+      mBlendEquation = blendEquation;
+      if(mRenderers)
       {
-        RendererPtr renderer = GetRendererAt(i);
-        renderer->SetBlendEquation(static_cast<DevelBlendEquation::Type>(blendEquation));
+        mRenderers->SetBlending(blendEquation);
       }
     }
     mIsBlendEquationSet = true;

diff --git a/dali/internal/event/actors/actor-impl.h b/dali/internal/event/actors/actor-impl.h
index 11bbfa7..a5ebcc3 100644 (file)
--- a/dali/internal/event/actors/actor-impl.h
+++ b/dali/internal/event/actors/actor-impl.h
@@ -30,6 +30,7 @@
 #include <dali/internal/event/actors/actor-declarations.h>
 #include <dali/internal/event/actors/actor-parent-impl.h>
 #include <dali/internal/event/actors/actor-parent.h>
+#include <dali/internal/event/actors/actor-renderer-container.h>
 #include <dali/internal/event/common/object-impl.h>
 #include <dali/internal/event/common/stage-def.h>
 #include <dali/internal/update/nodes/node-declarations.h>
@@ -57,10 +58,6 @@ class RenderTask;
 class Renderer;
 class Scene;
 
-using RendererPtr       = IntrusivePtr<Renderer>;
-using RendererContainer = std::vector<RendererPtr>;
-using RendererIter      = RendererContainer::iterator;
-
 class ActorDepthTreeNode;
 using DepthNodeMemoryPool = Dali::Internal::MemoryPoolObjectAllocator<ActorDepthTreeNode>;
 
@@ -170,7 +167,7 @@ public:
   bool IsRenderable() const
   {
     // inlined as this is called a lot in hit testing
-    return mRenderers && !mRenderers->empty();
+    return mRenderers && !mRenderers->IsEmpty();
   }
 
   /**

diff --git a/dali/internal/event/actors/actor-renderer-container.cpp b/dali/internal/event/actors/actor-renderer-container.cpp
new file mode 100644 (file)
index 0000000..1083fcb
--- /dev/null
+++ b/dali/internal/event/actors/actor-renderer-container.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2021 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <dali/internal/event/actors/actor-renderer-container.h>
+#include <dali/internal/event/rendering/renderer-impl.h>
+#include <dali/internal/update/manager/update-manager.h>
+
+namespace Dali::Internal
+{
+RendererContainer::RendererContainer(EventThreadServices& eventThreadServices)
+: mEventThreadServices(eventThreadServices)
+{
+}
+
+uint32_t RendererContainer::Add(const SceneGraph::Node& node, Renderer& renderer, bool blending, DevelBlendEquation::Type blendEquation)
+{
+  if(blending)
+  {
+    renderer.SetBlendEquation(blendEquation);
+  }
+
+  uint32_t    index       = static_cast<uint32_t>(mRenderers.size());
+  RendererPtr rendererPtr = RendererPtr(&renderer);
+  mRenderers.push_back(rendererPtr);
+  AttachRendererMessage(mEventThreadServices.GetUpdateManager(), node, renderer.GetRendererSceneObject());
+  return index;
+}
+
+void RendererContainer::Remove(const SceneGraph::Node& node, Renderer& renderer)
+{
+  auto end = mRenderers.end();
+  for(auto iter = mRenderers.begin(); iter != end; ++iter)
+  {
+    if((*iter).Get() == &renderer)
+    {
+      mRenderers.erase(iter);
+      DetachRendererMessage(mEventThreadServices, node, renderer.GetRendererSceneObject());
+      break;
+    }
+  }
+}
+
+void RendererContainer::Remove(const SceneGraph::Node& node, uint32_t index)
+{
+  if(index < mRenderers.size())
+  {
+    RendererPtr renderer = mRenderers[index];
+    DetachRendererMessage(mEventThreadServices, node, renderer->GetRendererSceneObject());
+    mRenderers.erase(mRenderers.begin() + index);
+  }
+}
+
+uint32_t RendererContainer::GetCount() const
+{
+  return static_cast<uint32_t>(mRenderers.size());
+}
+
+RendererPtr RendererContainer::GetRendererAt(uint32_t index) const
+{
+  return index < mRenderers.size() ? mRenderers[index] : nullptr;
+}
+
+void RendererContainer::SetBlending(DevelBlendEquation::Type blendEquation)
+{
+  for(auto renderer : mRenderers)
+  {
+    renderer->SetBlendEquation(static_cast<DevelBlendEquation::Type>(blendEquation));
+  }
+}
+
+} // namespace Dali::Internal

diff --git a/dali/internal/event/actors/actor-renderer-container.h b/dali/internal/event/actors/actor-renderer-container.h
new file mode 100644 (file)
index 0000000..3dac160
--- /dev/null
+++ b/dali/internal/event/actors/actor-renderer-container.h
@@ -0,0 +1,103 @@
+#ifndef DALI_INTERNAL_ACTORS_ACTOR_RENDERER_CONTAINER_H
+#define DALI_INTERNAL_ACTORS_ACTOR_RENDERER_CONTAINER_H
+
+/*
+ * Copyright (c) 2021 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dali/devel-api/rendering/renderer-devel.h>
+#include <dali/internal/event/common/event-thread-services.h>
+
+namespace Dali::Internal
+{
+using RendererPtr = IntrusivePtr<Renderer>;
+class Renderer;
+
+namespace SceneGraph
+{
+class Node;
+}
+
+/**
+ * Class to contain an actor's renderers.
+ * Enables actor to set the blending for all renderers at once.
+ */
+class RendererContainer
+{
+public:
+  /**
+   * Constructor.
+   *
+   * @param[in] eventThreadServices - thread services for sending messages
+   */
+  RendererContainer(EventThreadServices& eventThreadServices);
+
+  /**
+   * Add a renderer to this actor & actor's node, with blending applied if necessary.
+   * @param[in] node The node to add this renderer's scene graph object to
+   * @param[in] renderer the renderer to add
+   * @param[in] blending If blending equation should be applied to this renderer
+   * @param[in] blendEquation The current blending equation
+   */
+  uint32_t Add(const SceneGraph::Node& node, Renderer& renderer, bool blending, DevelBlendEquation::Type blendEquation);
+
+  /**
+   * Remove the renderer, if present
+   * @param[in] node The node to remove this renderer's scene graph object from
+   * @param[in] renderer The renderer to remove
+   */
+  void Remove(const SceneGraph::Node& node, Renderer& renderer);
+
+  /**
+   * Remove the renderer at given index
+   * @param[in] node The node to remove this renderer's scene graph object from
+   * @param[in] index The index of the renderer to remove
+   */
+  void Remove(const SceneGraph::Node& node, uint32_t index);
+
+  /**
+   * Return the number of renderers
+   * @return the number of renderers
+   */
+  uint32_t GetCount() const;
+
+  /**
+   * @return true if there aren't any renderers
+   */
+  bool IsEmpty() const
+  {
+    return mRenderers.empty();
+  }
+
+  /**
+   * Get the renderer at the given index, if in range.
+   * @param[in] index The index of the renderer to return
+   * @return A renderer at the given index, or nullptr if out of range
+   */
+  RendererPtr GetRendererAt(uint32_t index) const;
+
+  /**
+   * Set the blending equation for all renderers
+   */
+  void SetBlending(DevelBlendEquation::Type blendEquation);
+
+private:
+  EventThreadServices&     mEventThreadServices; ///< The event thread services (for sending messages)
+  std::vector<RendererPtr> mRenderers;           ///< The contained renderers
+};
+
+} // namespace Dali::Internal
+
+#endif //DALI_INTERNAL_ACTORS_ACTOR_RENDERER_CONTAINER_H

diff --git a/dali/internal/file.list b/dali/internal/file.list
index 0345097..9f4ad89 100644 (file)
--- a/dali/internal/file.list
+++ b/dali/internal/file.list
@@ -15,6 +15,7 @@ SET( internal_src_files
   ${internal_src_dir}/event/actors/actor-impl.cpp
   ${internal_src_dir}/event/actors/actor-coords.cpp
   ${internal_src_dir}/event/actors/actor-property-handler.cpp
+  ${internal_src_dir}/event/actors/actor-renderer-container.cpp
   ${internal_src_dir}/event/actors/actor-relayouter.cpp
   ${internal_src_dir}/event/actors/actor-parent-impl.cpp
   ${internal_src_dir}/event/actors/custom-actor-internal.cpp