X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Fcommon%2Fscene-impl.cpp;h=56ed507756bf385c62114311380bb8607789c755;hb=eacc080fe975c523d722dd17c044652317ddd6e8;hp=30a4a0f982b5e1d575a04accc08b64e87cfaadbc;hpb=b0f4fa0ba05ad183d682bb93b56afbae6e5186c4;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/common/scene-impl.cpp b/dali/internal/event/common/scene-impl.cpp index 30a4a0f..56ed507 100644 --- a/dali/internal/event/common/scene-impl.cpp +++ b/dali/internal/event/common/scene-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 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. @@ -19,128 +19,139 @@ #include // INTERNAL INCLUDES +#include #include #include -#include +#include #include -#include #include -#include -#include +#include +#include +#include +#include #include +#include +#include #include #include -#include -#include using Dali::Internal::SceneGraph::Node; namespace Dali { - namespace Internal { - -namespace +ScenePtr Scene::New(Size size, int32_t windowOrientation, int32_t screenOrientation) { - -const Vector4 DEFAULT_BACKGROUND_COLOR(0.0f, 0.0f, 0.0f, 1.0f); // Default background color - -} //Unnamed namespace - -ScenePtr Scene::New( const Size& size ) -{ - ScenePtr scene = new Scene( size ); + ScenePtr scene = new Scene; // Second-phase construction - scene->Initialize(); + scene->Initialize(size, windowOrientation, screenOrientation); return scene; } -Scene::Scene( const Size& size ) -: mSurface( nullptr ), - mSize( size ), - mSurfaceSize( Vector2::ZERO ), - mDpi( Vector2::ZERO ), - mDepthTreeDirty( false ), - mEventProcessor( *this, ThreadLocalStorage::GetInternal()->GetGestureEventProcessor() ) +Scene::Scene() +: mSceneObject(nullptr), + mSize(), // Don't set the proper value here, this will be set when the surface is set later + mDpi(), + mBackgroundColor(DEFAULT_BACKGROUND_COLOR), + mDepthTreeDirty(false), + mEventProcessor(*this, ThreadLocalStorage::GetInternal()->GetGestureEventProcessor()), + mSurfaceOrientation(0), + mScreenOrientation(0) { } Scene::~Scene() { - if( mDefaultCamera ) + if(EventThreadServices::IsCoreRunning() && mSceneObject) + { + ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); + RemoveSceneMessage(tls->GetUpdateManager(), *mSceneObject); + } + + if(mDefaultCamera) { // its enough to release the handle so the object is released // don't need to remove it from root actor as root actor will delete the object mDefaultCamera.Reset(); } - if( mRootLayer ) + if(mRootLayer) { // we are closing down so just delete the root, no point emit disconnect // signals or send messages to update mRootLayer.Reset(); } - if( mRenderTaskList ) + if(mOverlayLayer) { - mRenderTaskList.Reset(); + mOverlayLayer.Reset(); } - if( ThreadLocalStorage::Created() ) + if(mRenderTaskList) { - ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); - tls->RemoveScene( this ); + mRenderTaskList.Reset(); } + + // No need to discard this Scene from Core, as Core stores an intrusive_ptr to this scene + // When this destructor is called, the scene has either already been removed from Core or Core has already been destroyed } -void Scene::Initialize() +void Scene::Initialize(Size size, int32_t windowOrientation, int32_t screenOrientation) { ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); - DALI_ASSERT_ALWAYS( tls && "Attempt to create scene before core exists!" ); + DALI_ASSERT_ALWAYS(tls && "Attempt to create scene before core exists!"); - tls->AddScene( this ); + tls->AddScene(this); SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager(); // Create the ordered list of layers - mLayerList = LayerList::New( updateManager ); + mLayerList = LayerList::New(updateManager); // The scene owns the default layer - mRootLayer = Layer::NewRoot( *mLayerList, updateManager ); + mRootLayer = Layer::NewRoot(*mLayerList); mRootLayer->SetName("RootLayer"); - mRootLayer->SetScene( *this ); + mRootLayer->SetScene(*this); // The root layer needs to have a fixed resize policy (as opposed to the default USE_NATURAL_SIZE). // This stops actors parented to the stage having their relayout requests propagating // up to the root layer, and down through other children unnecessarily. - mRootLayer->SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS ); + mRootLayer->SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); // Create the default camera actor first; this is needed by the RenderTaskList // The default camera attributes and position is such that children of the default layer, // can be positioned at (0,0) and be at the top-left of the viewport. - mDefaultCamera = CameraActor::New( mSize ); + mDefaultCamera = CameraActor::New(size); mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER); Add(*(mDefaultCamera.Get())); // Create the list of render-tasks mRenderTaskList = RenderTaskList::New(); - // Create the default render-task - mRenderTaskList->CreateTask( mRootLayer.Get(), mDefaultCamera.Get() ); + // Create the default render-task and ensure clear is enabled on it to show the background color + RenderTaskPtr renderTask = mRenderTaskList->CreateTask(mRootLayer.Get(), mDefaultCamera.Get()); + renderTask->SetClearEnabled(true); + + // Create scene graph object + mSceneObject = new SceneGraph::Scene(); + OwnerPointer transferOwnership(const_cast(mSceneObject)); + AddSceneMessage(updateManager, transferOwnership); + + SurfaceRotated(size.width, size.height, windowOrientation, screenOrientation); } void Scene::Add(Actor& actor) { - mRootLayer->Add( actor ); + mRootLayer->Add(actor); } void Scene::Remove(Actor& actor) { - mRootLayer->Remove( actor ); + mRootLayer->Remove(actor); } Size Scene::GetSize() const @@ -165,7 +176,27 @@ RenderTaskList& Scene::GetRenderTaskList() const Dali::Layer Scene::GetRootLayer() const { - return Dali::Layer( mRootLayer.Get() ); + return Dali::Layer(mRootLayer.Get()); +} + +Dali::Layer Scene::GetOverlayLayer() +{ + if(!mOverlayLayer) + { + // Creates overlay layer. + mOverlayLayer = Layer::New(); + mOverlayLayer->SetName("OverlayLayer"); + mOverlayLayer->SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS); + mOverlayLayer->SetParentOrigin(Dali::ParentOrigin::TOP_LEFT); + mOverlayLayer->SetAnchorPoint(Dali::AnchorPoint::TOP_LEFT); + mRootLayer->Add(*mOverlayLayer); + + // Create the overlay render-task and set exclusive to true. + RenderTaskPtr renderTask = mRenderTaskList->CreateOverlayTask(mOverlayLayer.Get(), mDefaultCamera.Get()); + renderTask->SetExclusive(true); + renderTask->SetInputEnabled(true); + } + return Dali::Layer(mOverlayLayer.Get()); } LayerList& Scene::GetLayerList() const @@ -178,12 +209,12 @@ uint32_t Scene::GetLayerCount() const return mLayerList->GetLayerCount(); } -Dali::Layer Scene::GetLayer( uint32_t depth ) const +Dali::Layer Scene::GetLayer(uint32_t depth) const { - return Dali::Layer(mLayerList->GetLayer( depth )); + return Dali::Layer(mLayerList->GetLayer(depth)); } -CameraActor& Scene::GetDefaultCameraActor() +CameraActor& Scene::GetDefaultCameraActor() const { return *mDefaultCamera; } @@ -193,45 +224,30 @@ Actor& Scene::GetDefaultRootActor() return *mRootLayer; } -void Scene::SetSurface( Integration::RenderSurface& surface ) +void Scene::SurfaceResized(float width, float height) { - mSurface = &surface; - if ( mSurface ) + if((fabsf(mSize.width - width) > Math::MACHINE_EPSILON_1) || (fabsf(mSize.height - height) > Math::MACHINE_EPSILON_1)) { - mSurfaceSize.width = static_cast( mSurface->GetPositionSize().width ); - mSurfaceSize.height = static_cast( mSurface->GetPositionSize().height ); - - mSize.width = mSurfaceSize.width; - mSize.height = mSurfaceSize.height; - - // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position. - mDefaultCamera->SetPerspectiveProjection( mSurfaceSize ); - - mRootLayer->SetSize( mSize.width, mSize.height ); + ChangedSurface(width, height, mSurfaceOrientation, mScreenOrientation); + } +} +void Scene::SurfaceReplaced() +{ + if(mSceneObject) + { ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); - SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager(); - SetDefaultSurfaceRectMessage( updateManager, Rect( 0, 0, static_cast( mSurfaceSize.width ), static_cast( mSurfaceSize.height ) ) ); // truncated - - RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask( 0u ); - - // if single render task to screen then set its viewport parameters - if( 1 == mRenderTaskList->GetTaskCount() ) - { - if( !defaultRenderTask->GetTargetFrameBuffer() ) - { - defaultRenderTask->SetViewport( Viewport( 0, 0, static_cast( mSurfaceSize.width ), static_cast( mSurfaceSize.height ) ) ); // truncated - } - } - - mFrameBuffer = Dali::Internal::FrameBuffer::New( surface, Dali::FrameBuffer::Attachment::NONE ); - defaultRenderTask->SetFrameBuffer( mFrameBuffer ); + SurfaceReplacedMessage(tls->GetUpdateManager(), *mSceneObject); } } -Integration::RenderSurface* Scene::GetSurface() const +void Scene::Discard() { - return mSurface; + if(ThreadLocalStorage::Created()) + { + ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); + tls->RemoveScene(this); + } } void Scene::RequestRebuildDepthTree() @@ -239,9 +255,9 @@ void Scene::RequestRebuildDepthTree() mDepthTreeDirty = true; } -void Scene::QueueEvent( const Integration::Event& event ) +void Scene::QueueEvent(const Integration::Event& event) { - mEventProcessor.QueueEvent( event ); + mEventProcessor.QueueEvent(event); } void Scene::ProcessEvents() @@ -252,46 +268,199 @@ void Scene::ProcessEvents() void Scene::RebuildDepthTree() { // If the depth tree needs rebuilding, do it in this frame only. - if( mDepthTreeDirty ) + if(mDepthTreeDirty) { - ActorPtr actor( mRootLayer.Get() ); + ActorPtr actor(mRootLayer.Get()); actor->RebuildDepthTree(); mDepthTreeDirty = false; } } -void Scene::SetBackgroundColor(Vector4 color) +void Scene::SetBackgroundColor(const Vector4& color) +{ + mBackgroundColor = color; + + mRenderTaskList->GetTask(0u)->SetClearColor(color); + mRenderTaskList->GetTask(0u)->SetClearEnabled(true); +} + +Vector4 Scene::GetBackgroundColor() const { - if( mSurface ) + return mBackgroundColor; +} + +SceneGraph::Scene* Scene::GetSceneObject() const +{ + return mSceneObject; +} + +void Scene::EmitKeyEventSignal(const Dali::KeyEvent& event) +{ + if(!mKeyEventSignal.Empty()) { - mSurface->SetBackgroundColor( color ); + Dali::Integration::Scene handle(this); + mKeyEventSignal.Emit(event); } } -Vector4 Scene::GetBackgroundColor() const +void Scene::SurfaceRotated(float width, float height, int32_t windowOrientation, int32_t screenOrientation) +{ + ChangedSurface(width, height, windowOrientation, screenOrientation); +} + +int32_t Scene::GetCurrentSurfaceOrientation() const +{ + return mSceneObject->GetSurfaceOrientation(); +} + +int32_t Scene::GetCurrentScreenOrientation() const +{ + return mSceneObject->GetScreenOrientation(); +} + +const Rect& Scene::GetCurrentSurfaceRect() const +{ + return mSceneObject->GetSurfaceRect(); +} + +void Scene::ChangedSurface(float width, float height, int32_t windowOrientation, int32_t screenOrientation) +{ + bool changedOrientation = false; + Rect newSize(0, 0, static_cast(width), static_cast(height)); // truncated + mSize.width = width; + mSize.height = height; + + if(mSurfaceOrientation != windowOrientation || mScreenOrientation != screenOrientation) + { + changedOrientation = true; + } + + mSurfaceOrientation = windowOrientation; + mScreenOrientation = screenOrientation; + + // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position. + mDefaultCamera->SetPerspectiveProjection(mSize); + // Set the surface orientation to Default camera for window/screen rotation + if(changedOrientation) + { + int32_t orientation = (windowOrientation + screenOrientation) % 360; + mDefaultCamera->RotateProjection(orientation); + } + + mRootLayer->SetSize(width, height); + + // Send the surface rectangle/orientation to SceneGraph::Scene for calculating glViewport/Scissor + ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); + DALI_LOG_RELEASE_INFO("Send Surface Rect Message, width[%d], height[%d]\n", newSize.width, newSize.height); + SetSurfaceRectMessage(tls->GetEventThreadServices(), *mSceneObject, newSize); + if(changedOrientation) + { + DALI_LOG_RELEASE_INFO("Send Surface Orientation Message, surface orientation[%d], screen orientation[%d]\n", mSurfaceOrientation, mScreenOrientation); + SetSurfaceOrientationsMessage(tls->GetEventThreadServices(), *mSceneObject, mSurfaceOrientation, mScreenOrientation); + } + + // set default render-task viewport parameters + RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask(0u); + defaultRenderTask->SetViewport(newSize); + // set overlay render-task viewport parameters + RenderTaskPtr overlayRenderTask = mRenderTaskList->GetOverlayTask(); + if(overlayRenderTask) + { + overlayRenderTask->SetViewport(newSize); + } +} + +bool Scene::IsSurfaceRectChanged() const +{ + return mSceneObject->IsSurfaceRectChanged(); +} + +bool Scene::IsRotationCompletedAcknowledgementSet() const +{ + return mSceneObject->IsRotationCompletedAcknowledgementSet(); +} + +void Scene::SetRotationCompletedAcknowledgement() +{ + ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); + SetRotationCompletedAcknowledgementMessage(tls->GetEventThreadServices(), *mSceneObject); +} + +void Scene::SetSurfaceRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo) +{ + // Send the surface render target to SceneGraph::Scene + ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); + SetSurfaceRenderTargetCreateInfoMessage(tls->GetEventThreadServices(), *mSceneObject, renderTargetCreateInfo); +} + +bool Scene::EmitKeyEventGeneratedSignal(const Dali::KeyEvent& event) { - return mSurface ? mSurface->GetBackgroundColor() : DEFAULT_BACKGROUND_COLOR; + // Emit the KeyEventGenerated signal when KeyEvent is generated + Dali::Integration::Scene handle(this); + return mKeyEventGeneratedSignal.Emit(event); } -void Scene::EmitKeyEventSignal(const KeyEvent& event) +bool Scene::EmitInterceptKeyEventSignal(const Dali::KeyEvent& event) { - mKeyEventSignal.Emit( event ); + // Emit the InterceptKeyEvent signal + Dali::Integration::Scene handle(this); + return mInterceptKeyEventSignal.Emit(event); } void Scene::EmitEventProcessingFinishedSignal() { - mEventProcessingFinishedSignal.Emit(); + if(!mEventProcessingFinishedSignal.Empty()) + { + Dali::Integration::Scene handle(this); + mEventProcessingFinishedSignal.Emit(); + } } -void Scene::EmitTouchedSignal( const TouchEvent& touchEvent, const Dali::TouchData& touch ) +void Scene::EmitTouchedSignal(const Dali::TouchEvent& touch) { - mTouchedSignal.Emit( touchEvent ); - mTouchSignal.Emit( touch ); + Dali::Integration::Scene handle(this); + if(!mTouchedSignal.Empty()) + { + mTouchedSignal.Emit(touch); + } +} + +void Scene::EmitWheelEventSignal(const Dali::WheelEvent& event) +{ + if(!mWheelEventSignal.Empty()) + { + Dali::Integration::Scene handle(this); + mWheelEventSignal.Emit(event); + } } -void Scene::EmitWheelEventSignal(const WheelEvent& event) +bool Scene::EmitWheelEventGeneratedSignal(const Dali::WheelEvent& event) { - mWheelEventSignal.Emit( event ); + // Emit the WheelEventGenerated signal when WheelEvent is generated + Dali::Integration::Scene handle(this); + return mWheelEventGeneratedSignal.Emit(event); +} + +void Scene::AddFrameRenderedCallback(std::unique_ptr callback, int32_t frameId) +{ + ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); + AddFrameRenderedCallbackMessage(tls->GetEventThreadServices(), *mSceneObject, callback.release(), frameId); +} + +void Scene::AddFramePresentedCallback(std::unique_ptr callback, int32_t frameId) +{ + ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); + AddFramePresentedCallbackMessage(tls->GetEventThreadServices(), *mSceneObject, callback.release(), frameId); +} + +void Scene::GetFrameRenderedCallback(Dali::Integration::Scene::FrameCallbackContainer& callbacks) +{ + mSceneObject->GetFrameRenderedCallback(callbacks); +} + +void Scene::GetFramePresentedCallback(Dali::Integration::Scene::FrameCallbackContainer& callbacks) +{ + mSceneObject->GetFramePresentedCallback(callbacks); } Integration::Scene::KeyEventSignalType& Scene::KeyEventSignal() @@ -299,26 +468,36 @@ Integration::Scene::KeyEventSignalType& Scene::KeyEventSignal() return mKeyEventSignal; } +Integration::Scene::KeyEventGeneratedSignalType& Scene::KeyEventGeneratedSignal() +{ + return mKeyEventGeneratedSignal; +} + +Integration::Scene::KeyEventGeneratedSignalType& Scene::InterceptKeyEventSignal() +{ + return mInterceptKeyEventSignal; +} + Integration::Scene::EventProcessingFinishedSignalType& Scene::EventProcessingFinishedSignal() { return mEventProcessingFinishedSignal; } -Scene::TouchedSignalType& Scene::TouchedSignal() +Integration::Scene::TouchEventSignalType& Scene::TouchedSignal() { return mTouchedSignal; } -Integration::Scene::TouchSignalType& Scene::TouchSignal() +Integration::Scene::WheelEventSignalType& Scene::WheelEventSignal() { - return mTouchSignal; + return mWheelEventSignal; } -Integration::Scene::WheelEventSignalType& Scene::WheelEventSignal() +Integration::Scene::WheelEventGeneratedSignalType& Scene::WheelEventGeneratedSignal() { - return mWheelEventSignal; + return mWheelEventGeneratedSignal; } -} // Internal +} // namespace Internal -} // Dali +} // namespace Dali