/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
#include <dali/internal/event/render-tasks/render-task-list-impl.h>
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
-#include <dali/internal/common/event-to-update.h>
-#include <dali/internal/event/common/thread-local-storage.h>
+#include <dali/internal/event/actors/camera-actor-impl.h>
+#include <dali/internal/event/common/event-thread-services.h>
+#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/event/render-tasks/render-task-defaults.h>
#include <dali/internal/event/render-tasks/render-task-impl.h>
-#include <dali/internal/event/actors/camera-actor-impl.h>
-#include <dali/internal/update/render-tasks/scene-graph-render-task.h>
-#include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
#include <dali/internal/update/manager/update-manager.h>
+#include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
+#include <dali/internal/update/render-tasks/scene-graph-render-task.h>
+#include <dali/public-api/common/dali-common.h>
using Dali::Internal::SceneGraph::UpdateManager;
namespace Internal
{
-RenderTaskList* RenderTaskList::New( UpdateManager& updateManager, RenderTaskDefaults& defaults, bool systemLevel )
+RenderTaskListPtr RenderTaskList::New()
{
- RenderTaskList* taskList = new RenderTaskList( updateManager.GetEventToUpdate(), defaults, systemLevel );
+ RenderTaskListPtr taskList = new RenderTaskList();
- taskList->Initialize( updateManager );
+ taskList->Initialize();
return taskList;
}
-Dali::RenderTask RenderTaskList::CreateTask()
+RenderTaskPtr RenderTaskList::CreateTask()
{
- RenderTask* taskImpl = RenderTask::New( mIsSystemLevel );
-
- Dali::RenderTask newTask( taskImpl );
- mTasks.push_back( newTask );
+ return CreateTask(&mDefaults.GetDefaultRootActor(), &mDefaults.GetDefaultCameraActor());
+}
- if ( mSceneObject )
+RenderTaskPtr RenderTaskList::CreateTask(Actor* sourceActor, CameraActor* cameraActor)
+{
+ RenderTaskPtr task = RenderTask::New(sourceActor, cameraActor, *this);
+ if(mOverlayRenderTask && mTasks.back() == mOverlayRenderTask)
{
- SceneGraph::RenderTask* sceneObject = taskImpl->CreateSceneObject();
- DALI_ASSERT_DEBUG( NULL != sceneObject );
-
- // Pass ownership to SceneGraph::RenderTaskList
- AddTaskMessage( mEventToUpdate, *mSceneObject, *sceneObject );
+ mTasks.insert(mTasks.end() - 1, task);
+ }
+ else
+ {
+ mTasks.push_back(task);
}
- // Set the default source & camera actors
- taskImpl->SetSourceActor( &mDefaults.GetDefaultRootActor() );
- taskImpl->SetCameraActor( &mDefaults.GetDefaultCameraActor() );
+ return task;
+}
- return newTask;
+RenderTaskPtr RenderTaskList::CreateOverlayTask(Actor* sourceActor, CameraActor* cameraActor)
+{
+ if(!mOverlayRenderTask)
+ {
+ mOverlayRenderTask = CreateTask(sourceActor, &mDefaults.GetDefaultCameraActor());
+ }
+ return mOverlayRenderTask;
}
-void RenderTaskList::RemoveTask( Dali::RenderTask task )
+void RenderTaskList::RemoveTask(Internal::RenderTask& task)
{
- for ( RenderTaskContainer::iterator iter = mTasks.begin(); mTasks.end() != iter; ++iter )
+ for(RenderTaskContainer::iterator iter = mTasks.begin(); mTasks.end() != iter; ++iter)
{
- if ( *iter == task )
- {
- if ( mSceneObject )
- {
- RenderTask& taskImpl = GetImplementation( task );
+ RenderTask* ptr = iter->Get();
- SceneGraph::RenderTask* sceneObject = taskImpl.GetRenderTaskSceneObject();
- DALI_ASSERT_DEBUG( NULL != sceneObject );
+ if(ptr == &task)
+ {
+ const SceneGraph::RenderTask& sceneObject = task.GetRenderTaskSceneObject();
- // Send a message to remove the scene-graph RenderTask
- RemoveTaskMessage( mEventToUpdate, *mSceneObject, *sceneObject );
+ // delete the task
+ mTasks.erase(iter);
+ // send a message to remove the scene-graph RenderTask
+ RemoveTaskMessage(mEventThreadServices, *mSceneObject, sceneObject);
- // The scene-graph RenderTask will be destroyed soon; discard the raw-pointer
- taskImpl.DiscardSceneObject();
+ Exclusive exclusive{ptr, ActorObserver()};
+ ExclusivesContainer::iterator exclusiveIter = find(mExclusives.begin(), mExclusives.end(), exclusive);
+ if(exclusiveIter != mExclusives.end())
+ {
+ mExclusives.erase(exclusiveIter);
}
-
- mTasks.erase( iter );
break; // we're finished
}
}
}
-unsigned int RenderTaskList::GetTaskCount() const
+uint32_t RenderTaskList::GetTaskCount() const
{
- return mTasks.size();
+ return static_cast<uint32_t>(mTasks.size()); // only 4,294,967,295 render tasks supported
}
-Dali::RenderTask RenderTaskList::GetTask( unsigned int index ) const
+RenderTaskPtr RenderTaskList::GetTask(uint32_t index) const
{
- DALI_ASSERT_ALWAYS( ( index < mTasks.size() ) && "RenderTask index out-of-range" );
+ DALI_ASSERT_ALWAYS((index < mTasks.size()) && "RenderTask index out-of-range");
return mTasks[index];
}
-RenderTaskList::RenderTaskList( EventToUpdate& eventToUpdate, RenderTaskDefaults& defaults, bool systemLevel )
-: mEventToUpdate( eventToUpdate ),
- mDefaults( defaults ),
- mIsSystemLevel( systemLevel ),
- mSceneObject( NULL )
+RenderTaskPtr RenderTaskList::GetOverlayTask() const
+{
+ RenderTaskPtr overlayRenderTask;
+ if(mOverlayRenderTask)
+ {
+ overlayRenderTask = mOverlayRenderTask;
+ }
+ return overlayRenderTask;
+}
+
+void RenderTaskList::SetExclusive(RenderTask* task, bool exclusive)
+{
+ // Check to see if this rendertask has an entry?
+ for(auto exclusiveIt = mExclusives.begin(); exclusiveIt != mExclusives.end(); ++exclusiveIt)
+ {
+ if(exclusiveIt->renderTaskPtr == task)
+ {
+ if(!exclusive)
+ {
+ mExclusives.erase(exclusiveIt);
+ break;
+ }
+ else
+ {
+ exclusiveIt->actor.SetActor(task->GetSourceActor());
+ exclusive = false;
+ break;
+ }
+ }
+ }
+ if(exclusive)
+ {
+ Exclusive exclusiveSlot;
+ exclusiveSlot.renderTaskPtr = task;
+ exclusiveSlot.actor.SetActor(task->GetSourceActor());
+ mExclusives.emplace_back(std::move(exclusiveSlot));
+ }
+}
+
+RenderTaskList::RenderTaskList()
+: mEventThreadServices(EventThreadServices::Get()),
+ mDefaults(*Stage::GetCurrent()),
+ mSceneObject(nullptr)
{
}
RenderTaskList::~RenderTaskList()
{
+ if(EventThreadServices::IsCoreRunning() && mSceneObject)
+ {
+ // Remove the render task list using a message to the update manager
+ RemoveRenderTaskListMessage(mEventThreadServices.GetUpdateManager(), *mSceneObject);
+ }
}
-void RenderTaskList::Initialize( UpdateManager& updateManager )
+void RenderTaskList::Initialize()
{
- // This should only be called once, with no existing scene-object
- DALI_ASSERT_DEBUG( NULL == mSceneObject );
+ // Create a new render task list, Keep a const pointer to the render task list.
+ mSceneObject = SceneGraph::RenderTaskList::New();
+
+ OwnerPointer<SceneGraph::RenderTaskList> transferOwnership(const_cast<SceneGraph::RenderTaskList*>(mSceneObject));
+ AddRenderTaskListMessage(mEventThreadServices.GetUpdateManager(), transferOwnership);
- // Get raw-pointer to render task list
- mSceneObject = updateManager.GetRenderTaskList( mIsSystemLevel );
// set the callback to call us back when tasks are completed
- mSceneObject->SetCompleteNotificationInterface( this );
+ mSceneObject->SetCompleteNotificationInterface(this);
}
void RenderTaskList::NotifyCompleted()
{
DALI_LOG_TRACE_METHOD(gLogRenderList);
- std::vector< Dali::RenderTask > finishedRenderTasks;
+ RenderTaskContainer finishedRenderTasks;
// Since render tasks can be unreferenced during the signal emissions, iterators into render tasks pointers may be invalidated.
// First copy the finished render tasks, then emit signals
- for ( std::vector<Dali::RenderTask>::iterator it = mTasks.begin(), endIt = mTasks.end(); it != endIt; ++it )
+ for(RenderTaskContainer::iterator iter = mTasks.begin(), endIt = mTasks.end(); iter != endIt; ++iter)
{
- Dali::RenderTask& renderTask( *it );
-
- if( GetImplementation( renderTask ).HasFinished() )
+ if((*iter)->HasFinished())
{
- finishedRenderTasks.push_back( Dali::RenderTask( renderTask ) );
+ finishedRenderTasks.push_back(*iter);
}
}
// Now it's safe to emit the signals
- for ( std::vector<Dali::RenderTask>::iterator it = finishedRenderTasks.begin(), endIt = finishedRenderTasks.end(); it != endIt; ++it )
+ for(auto&& item : finishedRenderTasks)
{
- Dali::RenderTask& handle( *it );
+ item->EmitSignalFinish();
+ }
+}
- GetImplementation(handle).EmitSignalFinish();
+void RenderTaskList::RecoverFromContextLoss()
+{
+ for(auto&& item : mTasks)
+ {
+ // If the render target renders only once to an offscreen, re-render the render task
+ if(item->GetRefreshRate() == Dali::RenderTask::REFRESH_ONCE && item->GetFrameBuffer())
+ {
+ item->SetRefreshRate(Dali::RenderTask::REFRESH_ONCE);
+ }
}
}
+const SceneGraph::RenderTaskList& RenderTaskList::GetSceneObject() const
+{
+ return *mSceneObject;
+}
+
} // namespace Internal
} // namespace Dali