dali/internal/update/render-tasks/scene-graph-render-task-list.h

   1 #ifndef DALI_INTERNAL_SCENE_GRAPH_RENDER_TASK_LIST_H
   2 #define DALI_INTERNAL_SCENE_GRAPH_RENDER_TASK_LIST_H
   3
   4 /*
   5  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/devel-api/common/owner-container.h>
  23 #include <dali/internal/common/message.h>
  24 #include <dali/internal/event/common/event-thread-services.h>
  25 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
  26
  27 namespace Dali
  28 {
  29 namespace Internal
  30 {
  31 class CompleteNotificationInterface;
  32
  33 namespace SceneGraph
  34 {
  35 class RenderMessageDispatcher;
  36 class RenderTask;
  37 class ResetterManager;
  38
  39 /**
  40  * An ordered list of render-tasks.
  41  */
  42 class RenderTaskList
  43 {
  44 public:
  45   using RenderTaskContainer = OwnerContainer<RenderTask*>;
  46
  47   /**
  48    * Construct a new RenderTaskList.
  49    * @return A new RenderTaskList
  50    */
  51   static RenderTaskList* New();
  52
  53   /**
  54    * Destructor
  55    */
  56   ~RenderTaskList();
  57
  58   /**
  59    * Overriden delete operator
  60    * Deletes the RenderTaskList from its global memory pool
  61    */
  62   void operator delete(void* ptr);
  63
  64   /**
  65    * Set the resetterManager and renderMessageDispatcher to send message.
  66    * @param[in] resetterManager to send resetter
  67    * @param[in] renderMessageDispatcher The renderMessageDispatcher to send messages.
  68    */
  69   void Initialize(ResetterManager& resetterManager, RenderMessageDispatcher& renderMessageDispatcher);
  70
  71   /**
  72    * Add a new RenderTask to the list.
  73    * @param[in] newTask The RenderTaskList takes ownership of this task.
  74    */
  75   void AddTask(OwnerPointer<RenderTask>& newTask);
  76
  77   /**
  78    * Remove a RenderTask from the list.
  79    * @param[in] task The RenderTaskList will destroy this task.
  80    */
  81   void RemoveTask(RenderTask* task);
  82
  83   /**
  84    * Retrieve the count of RenderTasks.
  85    * @return The count.
  86    */
  87   uint32_t GetTaskCount();
  88
  89   /**
  90    * Retrieve the container of RenderTasks.
  91    * @return The container.
  92    */
  93   RenderTaskContainer& GetTasks();
  94
  95   /**
  96    * Retrieve the container of RenderTasks.
  97    * @return The container.
  98    */
  99   const RenderTaskContainer& GetTasks() const;
 100
 101   /**
 102    * Set the notification method to package in the NotifyFinishedMessage
 103    * @param object to store in notification managers queue
 104    */
 105   void SetCompleteNotificationInterface(CompleteNotificationInterface* object);
 106
 107   /**
 108    * Get the Notification interface for when 1+ render tasks have finished
 109    */
 110   CompleteNotificationInterface* GetCompleteNotificationInterface();
 111
 112   /**
 113    * Get the capacity of the memory pools
 114    */
 115   static uint32_t GetMemoryPoolCapacity();
 116
 117   /**
 118    * @brief Sort RenderTasks along OrderIndex
 119    */
 120   void SortTasks(OwnerPointer<std::vector<const SceneGraph::RenderTask*>>& sortedTasks);
 121
 122 protected:
 123   /**
 124    * Protected constructor. See New()
 125    */
 126   RenderTaskList();
 127
 128 private:
 129   // Undefined
 130   RenderTaskList(const RenderTaskList&);
 131
 132   // Undefined
 133   RenderTaskList& operator=(const RenderTaskList&);
 134
 135 private:
 136   CompleteNotificationInterface* mNotificationObject;      ///< object to pass in to the complete notification
 137   ResetterManager*               mResetterManager;         ///< for sending bake resetter if rendertask initalized
 138   RenderMessageDispatcher*       mRenderMessageDispatcher; ///< for sending messages to render thread
 139   RenderTaskContainer            mRenderTasks;             ///< A container of owned RenderTasks
 140 };
 141
 142 // Messages for RenderTaskList
 143
 144 inline void AddTaskMessage(EventThreadServices& eventThreadServices, const RenderTaskList& list, OwnerPointer<RenderTask>& task)
 145 {
 146   // Message has ownership of the RenderTask while in transit from event -> update
 147   using LocalType = MessageValue1<RenderTaskList, OwnerPointer<RenderTask> >;
 148
 149   // Reserve some memory inside the message queue
 150   uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
 151
 152   // Construct message in the message queue memory; note that delete should not be called on the return value
 153   new(slot) LocalType(&list, &RenderTaskList::AddTask, task);
 154 }
 155
 156 inline void RemoveTaskMessage(EventThreadServices& eventThreadServices, const RenderTaskList& list, const RenderTask& constTask)
 157 {
 158   // Scene graph thread can destroy this object.
 159   RenderTask& task = const_cast<RenderTask&>(constTask);
 160
 161   using LocalType = MessageValue1<RenderTaskList, RenderTask*>;
 162
 163   // Reserve some memory inside the message queue
 164   uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
 165
 166   // Construct message in the message queue memory; note that delete should not be called on the return value
 167   new(slot) LocalType(&list, &RenderTaskList::RemoveTask, &task);
 168 }
 169
 170 inline void SortTasksMessage(EventThreadServices& eventThreadServices, const RenderTaskList& list, OwnerPointer<std::vector<const SceneGraph::RenderTask*>>& sortedTasks)
 171 {
 172   using LocalType = MessageValue1<RenderTaskList, OwnerPointer<std::vector<const SceneGraph::RenderTask*>>>;
 173
 174   // Reserve some memory inside the message queue
 175   uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
 176
 177   // Construct message in the message queue memory; note that delete should not be called on the return value
 178   new(slot) LocalType(&list, &RenderTaskList::SortTasks, sortedTasks);
 179 }
 180
 181 } // namespace SceneGraph
 182
 183 } // namespace Internal
 184
 185 } // namespace Dali
 186
 187 #endif // DALI_INTERNAL_SCENE_GRAPH_RENDER_TASK_LIST_H