/*
- * Copyright (c) 2019 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/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;
RenderTaskPtr RenderTaskList::CreateTask()
{
- return CreateTask( &mDefaults.GetDefaultRootActor(), &mDefaults.GetDefaultCameraActor() );
+ return CreateTask(&mDefaults.GetDefaultRootActor(), &mDefaults.GetDefaultCameraActor());
}
-RenderTaskPtr RenderTaskList::CreateTask( Actor* sourceActor, CameraActor* cameraActor)
+RenderTaskPtr RenderTaskList::CreateTask(Actor* sourceActor, CameraActor* cameraActor)
{
- RenderTaskPtr task = RenderTask::New( sourceActor, cameraActor, *this );
-
- mTasks.push_back( task );
+ RenderTaskPtr task = RenderTask::New(sourceActor, cameraActor, *this);
+ if(mOverlayRenderTask && mTasks.back() == mOverlayRenderTask)
+ {
+ mTasks.insert(mTasks.end() - 1, task);
+ }
+ else
+ {
+ mTasks.push_back(task);
+ }
return task;
}
-void RenderTaskList::RemoveTask( Internal::RenderTask& task )
+RenderTaskPtr RenderTaskList::CreateOverlayTask(Actor* sourceActor, CameraActor* cameraActor)
+{
+ if(!mOverlayRenderTask)
+ {
+ mOverlayRenderTask = CreateTask(sourceActor, &mDefaults.GetDefaultCameraActor());
+ }
+ return mOverlayRenderTask;
+}
+
+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->Get() == &task )
+ RenderTask* ptr = iter->Get();
+
+ if(ptr == &task)
{
const SceneGraph::RenderTask& sceneObject = task.GetRenderTaskSceneObject();
// delete the task
- mTasks.erase( iter );
+ mTasks.erase(iter);
// send a message to remove the scene-graph RenderTask
- RemoveTaskMessage( mEventThreadServices, *mSceneObject, sceneObject );
+ RemoveTaskMessage(mEventThreadServices, *mSceneObject, sceneObject);
- for ( Vector< Exclusive >::Iterator exclusiveIt = mExclusives.Begin(); exclusiveIt != mExclusives.End(); ++exclusiveIt )
+ Exclusive exclusive{ptr, ActorObserver()};
+ ExclusivesContainer::iterator exclusiveIter = find(mExclusives.begin(), mExclusives.end(), exclusive);
+ if(exclusiveIter != mExclusives.end())
{
- if ( exclusiveIt->renderTaskPtr == iter->Get() )
- {
- mExclusives.Erase( exclusiveIt );
- break;
- }
+ mExclusives.erase(exclusiveIter);
}
break; // we're finished
}
uint32_t RenderTaskList::GetTaskCount() const
{
- return static_cast<uint32_t>( mTasks.size() ); // only 4,294,967,295 render tasks supported
+ return static_cast<uint32_t>(mTasks.size()); // only 4,294,967,295 render tasks supported
}
-RenderTaskPtr RenderTaskList::GetTask( uint32_t 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];
+}
- return mTasks[ index ];
+RenderTaskPtr RenderTaskList::GetOverlayTask() const
+{
+ RenderTaskPtr overlayRenderTask;
+ if(mOverlayRenderTask)
+ {
+ overlayRenderTask = mOverlayRenderTask;
+ }
+ return overlayRenderTask;
}
-void RenderTaskList::SetExclusive( RenderTask* task, bool exclusive )
+void RenderTaskList::SetExclusive(RenderTask* task, bool exclusive)
{
// Check to see if this rendertask has an entry?
- for ( Vector< Exclusive >::Iterator exclusiveIt = mExclusives.Begin(); exclusiveIt != mExclusives.End(); ++exclusiveIt )
+ for(auto exclusiveIt = mExclusives.begin(); exclusiveIt != mExclusives.end(); ++exclusiveIt)
{
- if ( exclusiveIt->renderTaskPtr == task )
+ if(exclusiveIt->renderTaskPtr == task)
{
- if ( !exclusive )
+ if(!exclusive)
{
- mExclusives.Erase( exclusiveIt );
+ mExclusives.erase(exclusiveIt);
break;
}
else
{
- exclusiveIt->actorPtr = task->GetSourceActor();
+ exclusiveIt->actor.SetActor(task->GetSourceActor());
exclusive = false;
break;
}
}
}
- if ( exclusive )
+ if(exclusive)
{
Exclusive exclusiveSlot;
exclusiveSlot.renderTaskPtr = task;
- exclusiveSlot.actorPtr = task->GetSourceActor();
- mExclusives.PushBack( exclusiveSlot );
+ exclusiveSlot.actor.SetActor(task->GetSourceActor());
+ mExclusives.emplace_back(std::move(exclusiveSlot));
}
}
RenderTaskList::RenderTaskList()
-: mEventThreadServices( EventThreadServices::Get() ),
- mDefaults( *Stage::GetCurrent() ),
- mSceneObject( nullptr )
+: mEventThreadServices(EventThreadServices::Get()),
+ mDefaults(*Stage::GetCurrent()),
+ mSceneObject(nullptr)
{
}
RenderTaskList::~RenderTaskList()
{
- if( EventThreadServices::IsCoreRunning() && mSceneObject )
+ if(EventThreadServices::IsCoreRunning() && mSceneObject)
{
// Remove the render task list using a message to the update manager
- RemoveRenderTaskListMessage( mEventThreadServices.GetUpdateManager(), *mSceneObject );
+ RemoveRenderTaskListMessage(mEventThreadServices.GetUpdateManager(), *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 );
+ OwnerPointer<SceneGraph::RenderTaskList> transferOwnership(const_cast<SceneGraph::RenderTaskList*>(mSceneObject));
+ AddRenderTaskListMessage(mEventThreadServices.GetUpdateManager(), transferOwnership);
// set the callback to call us back when tasks are completed
- mSceneObject->SetCompleteNotificationInterface( this );
+ mSceneObject->SetCompleteNotificationInterface(this);
}
void RenderTaskList::NotifyCompleted()
// 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 ( RenderTaskContainer::iterator iter = mTasks.begin(), endIt = mTasks.end(); iter != endIt; ++iter )
+ for(RenderTaskContainer::iterator iter = mTasks.begin(), endIt = mTasks.end(); iter != endIt; ++iter)
{
- if( (*iter)->HasFinished() )
+ if((*iter)->HasFinished())
{
- finishedRenderTasks.push_back( *iter );
+ finishedRenderTasks.push_back(*iter);
}
}
// Now it's safe to emit the signals
- for ( auto&& item : finishedRenderTasks )
+ for(auto&& item : finishedRenderTasks)
{
item->EmitSignalFinish();
}
void RenderTaskList::RecoverFromContextLoss()
{
- for ( auto&& item : mTasks )
+ 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->GetTargetFrameBuffer() )
+ if(item->GetRefreshRate() == Dali::RenderTask::REFRESH_ONCE && item->GetFrameBuffer())
{
- item->SetRefreshRate( Dali::RenderTask::REFRESH_ONCE );
+ item->SetRefreshRate(Dali::RenderTask::REFRESH_ONCE);
}
}
}
projects / platform / core / uifw / dali-core.git / blobdiff