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

   1 /*
   2  * Copyright (c) 2021 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
  46 RenderTaskListPtr RenderTaskList::New()
  47 {
  48   RenderTaskListPtr taskList = new RenderTaskList();
  49
  50   taskList->Initialize();
  51
  52   return taskList;
  53 }
  54
  55 RenderTaskPtr RenderTaskList::CreateTask()
  56 {
  57   return CreateTask(&mDefaults.GetDefaultRootActor(), &mDefaults.GetDefaultCameraActor());
  58 }
  59
  60 RenderTaskPtr RenderTaskList::CreateTask(Actor* sourceActor, CameraActor* cameraActor)
  61 {
  62   RenderTaskPtr task = RenderTask::New(sourceActor, cameraActor, *this);
  63   if(mOverlayRenderTask && mTasks.back() == mOverlayRenderTask)
  64   {
  65     mTasks.insert(mTasks.end() - 1, task);
  66   }
  67   else
  68   {
  69     mTasks.push_back(task);
  70   }
  71
  72   return task;
  73 }
  74
  75 RenderTaskPtr RenderTaskList::CreateOverlayTask(Actor* sourceActor, CameraActor* cameraActor)
  76 {
  77   if(!mOverlayRenderTask)
  78   {
  79     mOverlayRenderTask = CreateTask(sourceActor, &mDefaults.GetDefaultCameraActor());
  80   }
  81   return mOverlayRenderTask;
  82 }
  83
  84 void RenderTaskList::RemoveTask(Internal::RenderTask& task)
  85 {
  86   for(RenderTaskContainer::iterator iter = mTasks.begin(); mTasks.end() != iter; ++iter)
  87   {
  88     RenderTask* ptr = iter->Get();
  89
  90     if(ptr == &task)
  91     {
  92       const SceneGraph::RenderTask& sceneObject = task.GetRenderTaskSceneObject();
  93
  94       // delete the task
  95       mTasks.erase(iter);
  96       // send a message to remove the scene-graph RenderTask
  97       RemoveTaskMessage(mEventThreadServices, *mSceneObject, sceneObject);
  98
  99       Exclusive exclusive{ptr, ActorObserver()};
 100       ExclusivesContainer::iterator exclusiveIter = find(mExclusives.begin(), mExclusives.end(), exclusive);
 101       if(exclusiveIter != mExclusives.end())
 102       {
 103         mExclusives.erase(exclusiveIter);
 104       }
 105       break; // we're finished
 106     }
 107   }
 108 }
 109
 110 uint32_t RenderTaskList::GetTaskCount() const
 111 {
 112   return static_cast<uint32_t>(mTasks.size()); // only 4,294,967,295 render tasks supported
 113 }
 114
 115 RenderTaskPtr RenderTaskList::GetTask(uint32_t index) const
 116 {
 117   DALI_ASSERT_ALWAYS((index < mTasks.size()) && "RenderTask index out-of-range");
 118
 119   return mTasks[index];
 120 }
 121
 122 RenderTaskPtr RenderTaskList::GetOverlayTask() const
 123 {
 124   RenderTaskPtr overlayRenderTask;
 125   if(mOverlayRenderTask)
 126   {
 127     overlayRenderTask = mOverlayRenderTask;
 128   }
 129   return overlayRenderTask;
 130 }
 131
 132 void RenderTaskList::SetExclusive(RenderTask* task, bool exclusive)
 133 {
 134   // Check to see if this rendertask has an entry?
 135   for(auto exclusiveIt = mExclusives.begin(); exclusiveIt != mExclusives.end(); ++exclusiveIt)
 136   {
 137     if(exclusiveIt->renderTaskPtr == task)
 138     {
 139       if(!exclusive)
 140       {
 141         mExclusives.erase(exclusiveIt);
 142         break;
 143       }
 144       else
 145       {
 146         exclusiveIt->actor.SetActor(task->GetSourceActor());
 147         exclusive = false;
 148         break;
 149       }
 150     }
 151   }
 152   if(exclusive)
 153   {
 154     Exclusive exclusiveSlot;
 155     exclusiveSlot.renderTaskPtr = task;
 156     exclusiveSlot.actor.SetActor(task->GetSourceActor());
 157     mExclusives.emplace_back(std::move(exclusiveSlot));
 158   }
 159 }
 160
 161 RenderTaskList::RenderTaskList()
 162 : mEventThreadServices(EventThreadServices::Get()),
 163   mDefaults(*Stage::GetCurrent()),
 164   mSceneObject(nullptr)
 165 {
 166 }
 167
 168 RenderTaskList::~RenderTaskList()
 169 {
 170   if(EventThreadServices::IsCoreRunning() && mSceneObject)
 171   {
 172     // Remove the render task list using a message to the update manager
 173     RemoveRenderTaskListMessage(mEventThreadServices.GetUpdateManager(), *mSceneObject);
 174   }
 175 }
 176
 177 void RenderTaskList::Initialize()
 178 {
 179   // Create a new render task list, Keep a const pointer to the render task list.
 180   mSceneObject = SceneGraph::RenderTaskList::New();
 181
 182   OwnerPointer<SceneGraph::RenderTaskList> transferOwnership(const_cast<SceneGraph::RenderTaskList*>(mSceneObject));
 183   AddRenderTaskListMessage(mEventThreadServices.GetUpdateManager(), transferOwnership);
 184
 185   // set the callback to call us back when tasks are completed
 186   mSceneObject->SetCompleteNotificationInterface(this);
 187 }
 188
 189 void RenderTaskList::NotifyCompleted()
 190 {
 191   DALI_LOG_TRACE_METHOD(gLogRenderList);
 192
 193   RenderTaskContainer finishedRenderTasks;
 194
 195   // Since render tasks can be unreferenced during the signal emissions, iterators into render tasks pointers may be invalidated.
 196   // First copy the finished render tasks, then emit signals
 197   for(RenderTaskContainer::iterator iter = mTasks.begin(), endIt = mTasks.end(); iter != endIt; ++iter)
 198   {
 199     if((*iter)->HasFinished())
 200     {
 201       finishedRenderTasks.push_back(*iter);
 202     }
 203   }
 204
 205   // Now it's safe to emit the signals
 206   for(auto&& item : finishedRenderTasks)
 207   {
 208     item->EmitSignalFinish();
 209   }
 210 }
 211
 212 void RenderTaskList::RecoverFromContextLoss()
 213 {
 214   for(auto&& item : mTasks)
 215   {
 216     // If the render target renders only once to an offscreen, re-render the render task
 217     if(item->GetRefreshRate() == Dali::RenderTask::REFRESH_ONCE && item->GetFrameBuffer())
 218     {
 219       item->SetRefreshRate(Dali::RenderTask::REFRESH_ONCE);
 220     }
 221   }
 222 }
 223
 224 const SceneGraph::RenderTaskList& RenderTaskList::GetSceneObject() const
 225 {
 226   return *mSceneObject;
 227 }
 228
 229 } // namespace Internal
 230
 231 } // namespace Dali