dali/internal/event/render-tasks/render-task-list-impl.cpp

   1 /*
   2  * Copyright (c) 2024 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/internal/event/actors/camera-actor-impl.h>
  23 #include <dali/internal/event/common/event-thread-services.h>
  24 #include <dali/internal/event/common/stage-impl.h>
  25 #include <dali/internal/event/render-tasks/render-task-defaults.h>
  26 #include <dali/internal/event/render-tasks/render-task-impl.h>
  27 #include <dali/internal/update/manager/update-manager.h>
  28 #include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
  29 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
  30 #include <dali/public-api/common/dali-common.h>
  31
  32 using Dali::Internal::SceneGraph::UpdateManager;
  33
  34 #if defined(DEBUG_ENABLED)
  35 namespace
  36 {
  37 Debug::Filter* gLogRenderList = Debug::Filter::New(Debug::Concise, false, "LOG_RENDER_TASK_LIST");
  38 }
  39 #endif
  40
  41 namespace Dali
  42 {
  43 namespace Internal
  44 {
  45 namespace
  46 {
  47 static constexpr uint32_t ORDER_INDEX_OVERLAY_RENDER_TASK = INT32_MAX;
  48 }
  49
  50 RenderTaskListPtr RenderTaskList::New()
  51 {
  52   RenderTaskListPtr taskList = new RenderTaskList();
  53
  54   taskList->Initialize();
  55
  56   return taskList;
  57 }
  58
  59 RenderTaskPtr RenderTaskList::CreateTask()
  60 {
  61   return CreateTask(&mDefaults.GetDefaultRootActor(), &mDefaults.GetDefaultCameraActor());
  62 }
  63
  64 RenderTaskPtr RenderTaskList::CreateTask(Actor* sourceActor, CameraActor* cameraActor, bool isOverlayTask)
  65 {
  66   RenderTaskPtr task = RenderTask::New(sourceActor, cameraActor, *this);
  67   mTasks.push_back(task);
  68
  69   if(isOverlayTask)
  70   {
  71     task->SetOrderIndex(ORDER_INDEX_OVERLAY_RENDER_TASK);
  72   }
  73
  74   // Setup mapping infomations between scenegraph rendertask
  75   this->MapNotifier(task->GetRenderTaskSceneObject(), *task);
  76
  77   return task;
  78 }
  79
  80 RenderTaskPtr RenderTaskList::CreateOverlayTask(Actor* sourceActor, CameraActor* cameraActor)
  81 {
  82   if(!mOverlayRenderTask)
  83   {
  84     mOverlayRenderTask = CreateTask(sourceActor, cameraActor, true);
  85   }
  86   return mOverlayRenderTask;
  87 }
  88
  89 void RenderTaskList::RemoveTask(Internal::RenderTask& task)
  90 {
  91   for(RenderTaskContainer::iterator iter = mTasks.begin(); mTasks.end() != iter; ++iter)
  92   {
  93     RenderTask* ptr = iter->Get();
  94
  95     if(ptr == &task)
  96     {
  97       if(mOverlayRenderTask == &task)
  98       {
  99         mOverlayRenderTask.Reset();
 100       }
 101
 102       // Remove mapping infomations
 103       this->UnmapNotifier(task.GetRenderTaskSceneObject());
 104
 105       // delete the task
 106       mTasks.erase(iter);
 107
 108       task.RemoveRenderTaskSceneObject(*this);
 109
 110       Exclusive                     exclusive{ptr, ActorObserver()};
 111       ExclusivesContainer::iterator exclusiveIter = find(mExclusives.begin(), mExclusives.end(), exclusive);
 112       if(exclusiveIter != mExclusives.end())
 113       {
 114         mExclusives.erase(exclusiveIter);
 115       }
 116       break; // we're finished
 117     }
 118   }
 119 }
 120
 121 uint32_t RenderTaskList::GetTaskCount() const
 122 {
 123   return static_cast<uint32_t>(mTasks.size()); // only 4,294,967,295 render tasks supported
 124 }
 125
 126 RenderTaskPtr RenderTaskList::GetTask(uint32_t index) const
 127 {
 128   DALI_ASSERT_ALWAYS((index < mTasks.size()) && "RenderTask index out-of-range");
 129
 130   return mTasks[index];
 131 }
 132
 133 RenderTaskPtr RenderTaskList::GetOverlayTask() const
 134 {
 135   RenderTaskPtr overlayRenderTask;
 136   if(mOverlayRenderTask)
 137   {
 138     overlayRenderTask = mOverlayRenderTask;
 139   }
 140   return overlayRenderTask;
 141 }
 142
 143 void RenderTaskList::SetExclusive(RenderTask* task, bool exclusive)
 144 {
 145   // Check to see if this rendertask has an entry?
 146   for(auto exclusiveIt = mExclusives.begin(); exclusiveIt != mExclusives.end(); ++exclusiveIt)
 147   {
 148     if(exclusiveIt->renderTaskPtr == task)
 149     {
 150       if(!exclusive)
 151       {
 152         mExclusives.erase(exclusiveIt);
 153         break;
 154       }
 155       else
 156       {
 157         exclusiveIt->actor.SetActor(task->GetSourceActor());
 158         exclusive = false;
 159         break;
 160       }
 161     }
 162   }
 163   if(exclusive)
 164   {
 165     Exclusive exclusiveSlot;
 166     exclusiveSlot.renderTaskPtr = task;
 167     exclusiveSlot.actor.SetActor(task->GetSourceActor());
 168     mExclusives.emplace_back(std::move(exclusiveSlot));
 169   }
 170 }
 171
 172 void RenderTaskList::SortTasks()
 173 {
 174   if(!mIsRequestedToSortTask)
 175   {
 176     return;
 177   }
 178
 179   std::stable_sort(mTasks.begin(), mTasks.end(), [](RenderTaskPtr first, RenderTaskPtr second) -> bool { return first->GetOrderIndex() < second->GetOrderIndex(); });
 180
 181   OwnerPointer<std::vector<const SceneGraph::RenderTask*>> sortedTasks(new std::vector<const SceneGraph::RenderTask*>());
 182   for(auto&& task : mTasks)
 183   {
 184     sortedTasks->push_back(task->GetRenderTaskSceneObject());
 185   }
 186   SortTasksMessage(mEventThreadServices, *mSceneObject, sortedTasks);
 187   mIsRequestedToSortTask = false;
 188 }
 189
 190 RenderTaskList::RenderTaskList()
 191 : mEventThreadServices(EventThreadServices::Get()),
 192   mDefaults(*Stage::GetCurrent()),
 193   mSceneObject(nullptr)
 194 {
 195 }
 196
 197 RenderTaskList::~RenderTaskList()
 198 {
 199   if(DALI_UNLIKELY(!Dali::Stage::IsCoreThread()))
 200   {
 201     DALI_LOG_ERROR("~RenderTaskList[%p] called from non-UI thread! something unknown issue will be happened!\n", this);
 202   }
 203
 204   if(DALI_LIKELY(EventThreadServices::IsCoreRunning() && mSceneObject))
 205   {
 206     // Remove the render task list using a message to the update manager
 207     RemoveRenderTaskListMessage(mEventThreadServices.GetUpdateManager(), *mSceneObject);
 208   }
 209 }
 210
 211 void RenderTaskList::Initialize()
 212 {
 213   // Create a new render task list, Keep a const pointer to the render task list.
 214   mSceneObject = SceneGraph::RenderTaskList::New();
 215
 216   OwnerPointer<SceneGraph::RenderTaskList> transferOwnership(const_cast<SceneGraph::RenderTaskList*>(mSceneObject));
 217   AddRenderTaskListMessage(mEventThreadServices.GetUpdateManager(), transferOwnership);
 218
 219   // set the callback to call us back when tasks are completed
 220   mSceneObject->SetCompleteNotificationInterface(this);
 221 }
 222
 223 void RenderTaskList::NotifyCompleted(CompleteNotificationInterface::ParameterList notifierIdList)
 224 {
 225   DALI_LOG_TRACE_METHOD(gLogRenderList);
 226
 227   RenderTaskContainer finishedRenderTasks;
 228
 229   for(const auto& notifierId : notifierIdList)
 230   {
 231     auto* renderTask = GetEventObject(notifierId);
 232     if(DALI_LIKELY(renderTask))
 233     {
 234       // Check if this render task hold inputed scenegraph render task.
 235       DALI_ASSERT_DEBUG(renderTask->GetRenderTaskSceneObject()->GetNotifyId() == notifierId);
 236
 237       if(renderTask->HasFinished())
 238       {
 239         finishedRenderTasks.push_back(renderTask);
 240       }
 241     }
 242   }
 243
 244   // Now it's safe to emit the signals
 245   for(auto&& item : finishedRenderTasks)
 246   {
 247     item->EmitSignalFinish();
 248   }
 249 }
 250
 251 void RenderTaskList::RecoverFromContextLoss()
 252 {
 253   for(auto&& item : mTasks)
 254   {
 255     // If the render target renders only once to an offscreen, re-render the render task
 256     if(item->GetRefreshRate() == Dali::RenderTask::REFRESH_ONCE && item->GetFrameBuffer())
 257     {
 258       item->SetRefreshRate(Dali::RenderTask::REFRESH_ONCE);
 259     }
 260   }
 261 }
 262
 263 const SceneGraph::RenderTaskList& RenderTaskList::GetSceneObject() const
 264 {
 265   return *mSceneObject;
 266 }
 267
 268 } // namespace Internal
 269
 270 } // namespace Dali