Change OffscreenRenderableType change by Register, instead of Set

We have multiple objects to try to change the custom-actor's OffscreenRenderableType.
Let we count the number of type called by bitfield, and check the enum by the counts.

Change-Id: I95049c17007a878a21316df73476cbe5841a1138
Signed-off-by: Eunki Hong <eunkiki.hong@samsung.com>

diff --git a/automated-tests/src/dali/utc-Dali-CustomActor.cpp b/automated-tests/src/dali/utc-Dali-CustomActor.cpp
index a989f1c10e935b3e314bc482bd7fbd5a3d9204c7..b2fc0c84a0f9bcb6067fcd974f2a32ce988213a9 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-CustomActor.cpp
+++ b/automated-tests/src/dali/utc-Dali-CustomActor.cpp
@@ -1850,7 +1850,7 @@ public:
   : UnregisteredCustomActor(impl)
   {
     mImpl = &impl;
-    mImpl->SetOffScreenRenderableType(type);
+    mImpl->RegisterOffScreenRenderableType(type);
   }
   Dali::RenderTask GetForwardRenderTask()
   {
@@ -1860,6 +1860,18 @@ public:
   {
     return mImpl->mBackwardRenderTask;
   }
+  void RegisterExternalOffScreenRenderableType(OffScreenRenderable::Type type)
+  {
+    tet_printf("type add : %d + %d\n", mImpl->GetOffScreenRenderableType(), type);
+    mImpl->RegisterOffScreenRenderableType(type);
+    mImpl->RequestRenderTaskReorder();
+  }
+  void UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type type)
+  {
+    tet_printf("type add : %d - %d\n", mImpl->GetOffScreenRenderableType(), type);
+    mImpl->UnregisterOffScreenRenderableType(type);
+    mImpl->RequestRenderTaskReorder();
+  }
   OffScreenRenderable::Type GetOffScreenRenderableType()
   {
     tet_printf("type : %d\n", mImpl->GetOffScreenRenderableType());
@@ -1885,7 +1897,7 @@ int UtcDaliCustomActorReordering(void)
    *      Fb   Gf
    *          / \
    *         H   I
-   * 
+   *
    * A, C are Layer. C has smaller Depth value than A.
    * B, E, F, G, and J are OffScreenCustomActor.
    * B, F, and J are Type BACKWARD.
@@ -1960,8 +1972,8 @@ int UtcDaliCustomActorReordering2(void)
    *          Al
    *       /     \
    *      Bb      Cb
-   * 
-   * A is Layer. 
+   *
+   * A is Layer.
    * B and C are BACKWARD OffScreenRenderable
    *
    * At the initial status, the OrderIndex of each RenderTask is
@@ -2030,6 +2042,195 @@ int UtcDaliCustomActorReordering2(void)
   END_TEST;
 }
 
+int UtcDaliCustomActorRegisterOffScreenRenderableTypeP(void)
+{
+  TestApplication application; // Need the type registry
+
+  DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 1, TEST_LOCATION);
+
+  /**
+   *        Al
+   *       /
+   *      Bb
+   *     / \
+   *    Cb  Df
+   *
+   * A is Layer.
+   * B and C are BACKWARD OffScreenRenderable,
+   * D is FORWARD OffScreenRenderable
+   *
+   * At the initial status, the OrderIndex of each RenderTask is
+   * B(Backward) - C(Backward) (D(Forward) is don't care)
+   *
+   *        Al
+   *       /
+   *      Bfb
+   *     / \
+   *   Cb   Df
+   *
+   * if we register B the forward renderable type, the OrderIndex of each RenderTask becomes
+   * (D(Forward) | C(Backward)) - B(Forward) - B(Backward)
+   *
+   *        Al
+   *       /
+   *      Bff
+   *     / \
+   *   Cfb   Df
+   *
+   * if we register B, C the forward renderable type again and B unregister backward,
+   * We don't care the order of C(Forward), C(Backward) and D(Forward).
+   * But all of them should be before B(Forward).
+   */
+
+  Layer                A_layer                = Layer::New();
+  OffScreenCustomActor B_offScreenCustomActor = OffScreenCustomActor::New(OffScreenRenderable::Type::BACKWARD);
+  OffScreenCustomActor C_offScreenCustomActor = OffScreenCustomActor::New(OffScreenRenderable::Type::BACKWARD);
+  OffScreenCustomActor D_offScreenCustomActor = OffScreenCustomActor::New(OffScreenRenderable::Type::FORWARD);
+
+  application.GetScene().Add(A_layer);
+
+  DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 1, TEST_LOCATION);
+  tet_printf("task cnt before : %d\n", application.GetScene().GetRenderTaskList().GetTaskCount());
+
+  A_layer.Add(B_offScreenCustomActor);
+  DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 3, TEST_LOCATION);
+
+  B_offScreenCustomActor.Add(C_offScreenCustomActor);
+  DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 5, TEST_LOCATION);
+
+  B_offScreenCustomActor.Add(D_offScreenCustomActor);
+  DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 7, TEST_LOCATION);
+
+  application.SendNotification();
+
+  tet_printf("B OrderIndex : %d, C OrderIndex : %d, D OrderIndex : %d\n", B_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex(), C_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex(), D_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex());
+  DALI_TEST_CHECK(B_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex() < C_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+
+  B_offScreenCustomActor.RegisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+  DALI_TEST_EQUALS(B_offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::BOTH, TEST_LOCATION);
+  application.SendNotification();
+
+  tet_printf("B OrderIndex : f %d b %d, C OrderIndex : %d, D OrderIndex : %d\n", B_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex(), B_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex(), C_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex(), D_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex());
+  DALI_TEST_CHECK(C_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex() < B_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex());
+  DALI_TEST_CHECK(D_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex() < B_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex());
+  DALI_TEST_CHECK(B_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex() < D_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex());
+
+  B_offScreenCustomActor.RegisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+  DALI_TEST_EQUALS(B_offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::BOTH, TEST_LOCATION);
+  C_offScreenCustomActor.RegisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+  DALI_TEST_EQUALS(C_offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::BOTH, TEST_LOCATION);
+  B_offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::BACKWARD);
+  DALI_TEST_EQUALS(B_offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::FORWARD, TEST_LOCATION);
+  application.SendNotification();
+
+  tet_printf("B OrderIndex : %d, C OrderIndex : f %d b %d, D OrderIndex : %d\n", B_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex(), C_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex(), C_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex(), D_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex());
+  DALI_TEST_CHECK(C_offScreenCustomActor.GetBackwardRenderTask().GetOrderIndex() < B_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex());
+  DALI_TEST_CHECK(C_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex() < B_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex());
+  DALI_TEST_CHECK(D_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex() < B_offScreenCustomActor.GetForwardRenderTask().GetOrderIndex());
+
+  tet_printf("Check unregister external type well\n");
+  B_offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+  DALI_TEST_EQUALS(B_offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::FORWARD, TEST_LOCATION);
+  B_offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+  DALI_TEST_EQUALS(B_offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::NONE, TEST_LOCATION);
+  C_offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::BACKWARD);
+  DALI_TEST_EQUALS(C_offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::FORWARD, TEST_LOCATION);
+  C_offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+  DALI_TEST_EQUALS(C_offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::NONE, TEST_LOCATION);
+  D_offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+  DALI_TEST_EQUALS(D_offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::NONE, TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliCustomActorRegisterOffScreenRenderableTypeN(void)
+{
+  TestApplication application; // Need the type registry
+
+  DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 1, TEST_LOCATION);
+
+  Layer                layer                = Layer::New();
+  OffScreenCustomActor offScreenCustomActor = OffScreenCustomActor::New(OffScreenRenderable::Type::NONE);
+
+  application.GetScene().Add(layer);
+
+  DALI_TEST_EQUALS(application.GetScene().GetRenderTaskList().GetTaskCount(), 1, TEST_LOCATION);
+
+  layer.Add(offScreenCustomActor);
+  application.SendNotification();
+
+  constexpr int MAX_REGISTERED_COUNT = 15;
+
+  for(int i = 0; i < MAX_REGISTERED_COUNT; ++i)
+  {
+    offScreenCustomActor.RegisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+    DALI_TEST_EQUALS(offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::FORWARD, TEST_LOCATION);
+  }
+
+  try
+  {
+    offScreenCustomActor.RegisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+    tet_result(TET_FAIL); // Should not reach here
+  }
+  catch(DaliException e)
+  {
+    DALI_TEST_ASSERT(e, "forward registered more than 16 times", TEST_LOCATION);
+  }
+
+  for(int i = 0; i < MAX_REGISTERED_COUNT; ++i)
+  {
+    offScreenCustomActor.RegisterExternalOffScreenRenderableType(OffScreenRenderable::Type::BACKWARD);
+    DALI_TEST_EQUALS(offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::BOTH, TEST_LOCATION);
+  }
+
+  try
+  {
+    offScreenCustomActor.RegisterExternalOffScreenRenderableType(OffScreenRenderable::Type::BACKWARD);
+    tet_result(TET_FAIL); // Should not reach here
+  }
+  catch(DaliException e)
+  {
+    DALI_TEST_ASSERT(e, "backward registered more than 16 times", TEST_LOCATION);
+  }
+
+  for(int i = 0; i < MAX_REGISTERED_COUNT - 1; ++i)
+  {
+    offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+    DALI_TEST_EQUALS(offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::BOTH, TEST_LOCATION);
+  }
+  offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+  DALI_TEST_EQUALS(offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::BACKWARD, TEST_LOCATION);
+
+  try
+  {
+    offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::FORWARD);
+    tet_result(TET_FAIL); // Should not reach here
+  }
+  catch(DaliException e)
+  {
+    DALI_TEST_ASSERT(e, "forward not registered before", TEST_LOCATION);
+  }
+
+  for(int i = 0; i < MAX_REGISTERED_COUNT - 1; ++i)
+  {
+    offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::BACKWARD);
+    DALI_TEST_EQUALS(offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::BACKWARD, TEST_LOCATION);
+  }
+  offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::BACKWARD);
+  DALI_TEST_EQUALS(offScreenCustomActor.GetOffScreenRenderableType(), OffScreenRenderable::Type::NONE, TEST_LOCATION);
+
+  try
+  {
+    offScreenCustomActor.UnregisterExternalOffScreenRenderableType(OffScreenRenderable::Type::BACKWARD);
+    tet_result(TET_FAIL); // Should not reach here
+  }
+  catch(DaliException e)
+  {
+    DALI_TEST_ASSERT(e, "backward not registered before", TEST_LOCATION);
+  }
+
+  END_TEST;
+}
+
 int UtcDaliCustomActorImplSetRemoveCacheRenderer(void)
 {
   TestApplication application;

diff --git a/dali/internal/event/actors/actor-impl.cpp b/dali/internal/event/actors/actor-impl.cpp
index b593bf7e079ea971be92e1f784146600eb1fec6d..39ea47ccfedc32f3b3281c1862a84ba9b10ae402 100644 (file)
--- a/dali/internal/event/actors/actor-impl.cpp
+++ b/dali/internal/event/actors/actor-impl.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.
@@ -377,6 +377,12 @@ ActorContainer& GetVisibilityChagnedActorStack()
   return gVisibilityChangedActorStack;
 }
 
+constexpr uint8_t EMPTY_OFF_SCREEN_RENDERABLE_BIT_FIELD     = 0x00;
+constexpr uint8_t OFF_SCREEN_RENDERABLE_TYPE_FORWARD_MASK   = 0x0f;
+constexpr uint8_t OFF_SCREEN_RENDERABLE_TYPE_FORWARD_VALUE  = 0x01;
+constexpr uint8_t OFF_SCREEN_RENDERABLE_TYPE_BACKWARD_MASK  = 0xf0;
+constexpr uint8_t OFF_SCREEN_RENDERABLE_TYPE_BACKWARD_VALUE = 0x10;
+
 } // unnamed namespace
 
 ActorPtr Actor::New()
@@ -1132,14 +1138,38 @@ void Actor::GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool i
 {
 }
 
-void Actor::SetOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType)
+void Actor::RegisterOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType)
+{
+  if(offScreenRenderableType & OffScreenRenderable::Type::FORWARD)
+  {
+    DALI_ASSERT_DEBUG((mOffScreenRenderableBitField & OFF_SCREEN_RENDERABLE_TYPE_FORWARD_MASK) != OFF_SCREEN_RENDERABLE_TYPE_FORWARD_MASK && "Off screen renderable type forward registered more than 16 times!");
+    mOffScreenRenderableBitField += OFF_SCREEN_RENDERABLE_TYPE_FORWARD_VALUE;
+  }
+  if(offScreenRenderableType & OffScreenRenderable::Type::BACKWARD)
+  {
+    DALI_ASSERT_DEBUG((mOffScreenRenderableBitField & OFF_SCREEN_RENDERABLE_TYPE_BACKWARD_MASK) != OFF_SCREEN_RENDERABLE_TYPE_BACKWARD_MASK && "Off screen renderable type backward registered more than 16 times!");
+    mOffScreenRenderableBitField += OFF_SCREEN_RENDERABLE_TYPE_BACKWARD_VALUE;
+  }
+}
+
+void Actor::UnregisterOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType)
 {
-  mOffScreenRenderableType = offScreenRenderableType;
+  if(offScreenRenderableType & OffScreenRenderable::Type::FORWARD)
+  {
+    DALI_ASSERT_DEBUG((mOffScreenRenderableBitField & OFF_SCREEN_RENDERABLE_TYPE_FORWARD_MASK) != 0 && "Off screen renderable type forward not registered before!");
+    mOffScreenRenderableBitField -= OFF_SCREEN_RENDERABLE_TYPE_FORWARD_VALUE;
+  }
+  if(offScreenRenderableType & OffScreenRenderable::Type::BACKWARD)
+  {
+    DALI_ASSERT_DEBUG((mOffScreenRenderableBitField & OFF_SCREEN_RENDERABLE_TYPE_BACKWARD_MASK) != 0 && "Off screen renderable type backward not registered before!");
+    mOffScreenRenderableBitField -= OFF_SCREEN_RENDERABLE_TYPE_BACKWARD_VALUE;
+  }
 }
 
 OffScreenRenderable::Type Actor::GetOffScreenRenderableType() const
 {
-  return mOffScreenRenderableType;
+  return ((mOffScreenRenderableBitField & OFF_SCREEN_RENDERABLE_TYPE_FORWARD_MASK) ? OffScreenRenderable::Type::FORWARD : OffScreenRenderable::Type::NONE) |
+         ((mOffScreenRenderableBitField & OFF_SCREEN_RENDERABLE_TYPE_BACKWARD_MASK) ? OffScreenRenderable::Type::BACKWARD : OffScreenRenderable::Type::NONE);
 }
 
 void Actor::RequestRenderTaskReorder()
@@ -1241,7 +1271,7 @@ Actor::Actor(DerivedType derivedType, const SceneGraph::Node& node)
   mClippingMode(ClippingMode::DISABLED),
   mHoverState(PointState::FINISHED),
   mBlendEquation(DevelBlendEquation::ADD),
-  mOffScreenRenderableType(OffScreenRenderable::Type::NONE)
+  mOffScreenRenderableBitField(EMPTY_OFF_SCREEN_RENDERABLE_BIT_FIELD)
 {
 }
 

diff --git a/dali/internal/event/actors/actor-impl.h b/dali/internal/event/actors/actor-impl.h
index a8d5fcaeca50da9d3af2ff0629059087aaf4fe9a..ec607ac3bba102b0f691751a4983d5b299bea5e4 100644 (file)
--- a/dali/internal/event/actors/actor-impl.h
+++ b/dali/internal/event/actors/actor-impl.h
@@ -2,7 +2,7 @@
 #define DALI_INTERNAL_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.
@@ -1611,13 +1611,25 @@ public:
   virtual void GetOffScreenRenderTasks(std::vector<Dali::RenderTask>& tasks, bool isForward);
 
   /**
-   * @brief Sets OffScreenRenderableType of this Actor.
+   * @brief Register OffScreenRenderableType of this Actor.
    * This method is called by child class to set type itself.
    *
    * @param[in] offScreenRenderableType OffScreenRenderableType for this Actor.
    * It could be one of NONE, FORWARD, BACKWARD, and BOTH.
+   * @note Each FORWARD / BACKWARD type could be added maxium 15 times.
+   * @post Call UnregisterOffScreenRenderableType() to unregister the type.
    */
-  void SetOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType);
+  void RegisterOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType);
+
+  /**
+   * @brief Unregister OffScreenRenderableType of this Actor.
+   * This method is called by child class to set type itself.
+   *
+   * @param[in] offScreenRenderableType OffScreenRenderableType for this Actor.
+   * It could be one of NONE, FORWARD, BACKWARD, and BOTH.
+   * @pre Call RegisterOffScreenRenderableType() before unregister the type.
+   */
+  void UnregisterOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType);
 
   /**
    * @brief Retrieves OffScreenRenderableType of this Actor.
@@ -2093,13 +2105,11 @@ protected:
   ClippingMode::Type       mClippingMode : 3;              ///< Cached: Determines which clipping mode (if any) to use.
   PointState::Type         mHoverState : 3;                ///< Stores the HoverEvent state of actor.
   DevelBlendEquation::Type mBlendEquation : 16;            ///< Cached: Determines which blend equation will be used to render renderers.
+  uint8_t                  mOffScreenRenderableBitField;   ///< Bit field to store the offscreen renderable type of this actor. 0xf0 is backward, 0x0f is forward.
 
 private:
   static ActorContainer mNullChildren; ///< Empty container (shared by all actors, returned by GetChildren() const)
 
-  // OffScreenRenderable
-  OffScreenRenderable::Type mOffScreenRenderableType;
-
   struct PropertyHandler;
   struct SiblingHandler;
 
@@ -2129,6 +2139,13 @@ inline const Internal::Actor& GetImplementation(const Dali::Actor& actor)
   return static_cast<const Internal::Actor&>(handle);
 }
 
+// specialization has to be done in the same namespace
+template<>
+struct EnableBitMaskOperators<OffScreenRenderable::Type>
+{
+  static const bool ENABLE = true;
+};
+
 } // namespace Dali
 
 #endif // DALI_INTERNAL_ACTOR_H

diff --git a/dali/public-api/actors/custom-actor-impl.cpp b/dali/public-api/actors/custom-actor-impl.cpp
index 5319deec0eaad5b1f08f41b28407a17de902933f..702f9f86f68e9e0b9011239ee0110185d5087e0b 100644 (file)
--- a/dali/public-api/actors/custom-actor-impl.cpp
+++ b/dali/public-api/actors/custom-actor-impl.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.
@@ -36,7 +36,17 @@ void CustomActorImpl::OnPropertySet(Property::Index index, const Property::Value
 
 void CustomActorImpl::SetOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType)
 {
-  mOwner->SetOffScreenRenderableType(offScreenRenderableType);
+  RegisterOffScreenRenderableType(offScreenRenderableType);
+}
+
+void CustomActorImpl::RegisterOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType)
+{
+  mOwner->RegisterOffScreenRenderableType(offScreenRenderableType);
+}
+
+void CustomActorImpl::UnregisterOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType)
+{
+  mOwner->UnregisterOffScreenRenderableType(offScreenRenderableType);
 }
 
 OffScreenRenderable::Type CustomActorImpl::GetOffScreenRenderableType()

diff --git a/dali/public-api/actors/custom-actor-impl.h b/dali/public-api/actors/custom-actor-impl.h
index 28501a568f3e076803f8259c60b1be56ddc6fba1..02e3396c683e39f1ea28c70bba98b1e60dee2366 100644 (file)
--- a/dali/public-api/actors/custom-actor-impl.h
+++ b/dali/public-api/actors/custom-actor-impl.h
@@ -2,7 +2,7 @@
 #define DALI_CUSTOM_ACTOR_IMPL_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.
@@ -196,11 +196,35 @@ public:
    * This method is called by child class to set type itself.
    *
    * @SINCE_2_3.43
+   * @DEPRECATED_2_4.17 Use RegisterOffScreenRenderableType() instead.
    * @param[in] offScreenRenderableType OffScreenRenderableType for this Actor.
    * It could be one of NONE, FORWARD, BACKWARD, and BOTH.
    */
   void SetOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType);
 
+  /**
+   * @brief Register OffScreenRenderableType of this Actor.
+   * This method is called by child class to set type itself.
+   *
+   * @SINCE_2_4.17
+   * @param[in] offScreenRenderableType OffScreenRenderableType for this Actor.
+   * It could be one of NONE, FORWARD, BACKWARD, and BOTH.
+   * @note Each FORWARD / BACKWARD type could be added maxium 15 times.
+   * @post Call UnregisterOffScreenRenderableType() to unregister the type.
+   */
+  void RegisterOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType);
+
+  /**
+   * @brief Unregister OffScreenRenderableType of this Actor.
+   * This method is called by child class to set type itself.
+   *
+   * @SINCE_2_4.17
+   * @param[in] offScreenRenderableType OffScreenRenderableType for this Actor.
+   * It could be one of NONE, FORWARD, BACKWARD, and BOTH.
+   * @pre Call RegisterOffScreenRenderableType() before unregister the type.
+   */
+  void UnregisterOffScreenRenderableType(OffScreenRenderable::Type offScreenRenderableType);
+
   /**
    * @brief Retrieves OffScreenRenderableType of this Actor.
    *