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

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