dali/internal/event/common/scene-impl.cpp

   1 /*
   2  * Copyright (c) 2021 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/common/scene-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/internal/event/actors/camera-actor-impl.h>
  23 #include <dali/internal/event/actors/layer-impl.h>
  24 #include <dali/internal/event/actors/layer-list.h>
  25 #include <dali/internal/event/common/object-registry-impl.h>
  26 #include <dali/internal/event/common/thread-local-storage.h>
  27 #include <dali/internal/event/render-tasks/render-task-impl.h>
  28 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
  29 #include <dali/internal/event/rendering/frame-buffer-impl.h>
  30 #include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
  31 #include <dali/internal/update/common/scene-graph-scene.h>
  32 #include <dali/internal/update/manager/update-manager.h>
  33 #include <dali/internal/update/nodes/node.h>
  34 #include <dali/public-api/common/constants.h>
  35 #include <dali/public-api/object/type-registry.h>
  36 #include <dali/public-api/render-tasks/render-task-list.h>
  37
  38 using Dali::Internal::SceneGraph::Node;
  39
  40 namespace Dali
  41 {
  42 namespace Internal
  43 {
  44 ScenePtr Scene::New(Size size, int32_t orientation)
  45 {
  46   ScenePtr scene = new Scene;
  47
  48   // Second-phase construction
  49   scene->Initialize(size, orientation);
  50
  51   return scene;
  52 }
  53
  54 Scene::Scene()
  55 : mSceneObject(nullptr),
  56   mSize(), // Don't set the proper value here, this will be set when the surface is set later
  57   mDpi(),
  58   mBackgroundColor(DEFAULT_BACKGROUND_COLOR),
  59   mDepthTreeDirty(false),
  60   mEventProcessor(*this, ThreadLocalStorage::GetInternal()->GetGestureEventProcessor()),
  61   mSurfaceOrientation(0)
  62 {
  63 }
  64
  65 Scene::~Scene()
  66 {
  67   if(EventThreadServices::IsCoreRunning() && mSceneObject)
  68   {
  69     ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
  70     RemoveSceneMessage(tls->GetUpdateManager(), *mSceneObject);
  71   }
  72
  73   if(mDefaultCamera)
  74   {
  75     // its enough to release the handle so the object is released
  76     // don't need to remove it from root actor as root actor will delete the object
  77     mDefaultCamera.Reset();
  78   }
  79
  80   if(mRootLayer)
  81   {
  82     // we are closing down so just delete the root, no point emit disconnect
  83     // signals or send messages to update
  84     mRootLayer.Reset();
  85   }
  86
  87   if(mRenderTaskList)
  88   {
  89     mRenderTaskList.Reset();
  90   }
  91
  92   // No need to discard this Scene from Core, as Core stores an intrusive_ptr to this scene
  93   // When this destructor is called, the scene has either already been removed from Core or Core has already been destroyed
  94 }
  95
  96 void Scene::Initialize(Size size, int32_t orientation)
  97 {
  98   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
  99
 100   DALI_ASSERT_ALWAYS(tls && "Attempt to create scene before core exists!");
 101
 102   tls->AddScene(this);
 103
 104   SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager();
 105
 106   // Create the ordered list of layers
 107   mLayerList = LayerList::New(updateManager);
 108
 109   // The scene owns the default layer
 110   mRootLayer = Layer::NewRoot(*mLayerList);
 111   mRootLayer->SetName("RootLayer");
 112   mRootLayer->SetScene(*this);
 113
 114   // The root layer needs to have a fixed resize policy (as opposed to the default USE_NATURAL_SIZE).
 115   // This stops actors parented to the stage having their relayout requests propagating
 116   // up to the root layer, and down through other children unnecessarily.
 117   mRootLayer->SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
 118
 119   // Create the default camera actor first; this is needed by the RenderTaskList
 120   // The default camera attributes and position is such that children of the default layer,
 121   // can be positioned at (0,0) and be at the top-left of the viewport.
 122   mDefaultCamera = CameraActor::New(size);
 123   mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER);
 124   Add(*(mDefaultCamera.Get()));
 125
 126   // Create the list of render-tasks
 127   mRenderTaskList = RenderTaskList::New();
 128
 129   // Create the default render-task and ensure clear is enabled on it to show the background color
 130   RenderTaskPtr renderTask = mRenderTaskList->CreateTask(mRootLayer.Get(), mDefaultCamera.Get());
 131   renderTask->SetClearEnabled(true);
 132
 133   // Create scene graph object
 134   mSceneObject = new SceneGraph::Scene();
 135   OwnerPointer<SceneGraph::Scene> transferOwnership(const_cast<SceneGraph::Scene*>(mSceneObject));
 136   AddSceneMessage(updateManager, transferOwnership);
 137
 138   SurfaceRotated(size.width, size.height, orientation);
 139 }
 140
 141 void Scene::Add(Actor& actor)
 142 {
 143   mRootLayer->Add(actor);
 144 }
 145
 146 void Scene::Remove(Actor& actor)
 147 {
 148   mRootLayer->Remove(actor);
 149 }
 150
 151 Size Scene::GetSize() const
 152 {
 153   return mSize;
 154 }
 155
 156 void Scene::SetDpi(Vector2 dpi)
 157 {
 158   mDpi = dpi;
 159 }
 160
 161 Vector2 Scene::GetDpi() const
 162 {
 163   return mDpi;
 164 }
 165
 166 RenderTaskList& Scene::GetRenderTaskList() const
 167 {
 168   return *mRenderTaskList;
 169 }
 170
 171 Dali::Layer Scene::GetRootLayer() const
 172 {
 173   return Dali::Layer(mRootLayer.Get());
 174 }
 175
 176 LayerList& Scene::GetLayerList() const
 177 {
 178   return *mLayerList;
 179 }
 180
 181 uint32_t Scene::GetLayerCount() const
 182 {
 183   return mLayerList->GetLayerCount();
 184 }
 185
 186 Dali::Layer Scene::GetLayer(uint32_t depth) const
 187 {
 188   return Dali::Layer(mLayerList->GetLayer(depth));
 189 }
 190
 191 CameraActor& Scene::GetDefaultCameraActor() const
 192 {
 193   return *mDefaultCamera;
 194 }
 195
 196 Actor& Scene::GetDefaultRootActor()
 197 {
 198   return *mRootLayer;
 199 }
 200
 201 void Scene::SurfaceResized(float width, float height)
 202 {
 203   if((fabsf(mSize.width - width) > Math::MACHINE_EPSILON_1) || (fabsf(mSize.height - height) > Math::MACHINE_EPSILON_1))
 204   {
 205     ChangedSurface(width, height, mSurfaceOrientation);
 206   }
 207 }
 208
 209 void Scene::SurfaceReplaced()
 210 {
 211   if(mSceneObject)
 212   {
 213     ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 214     SurfaceReplacedMessage(tls->GetUpdateManager(), *mSceneObject);
 215   }
 216 }
 217
 218 void Scene::Discard()
 219 {
 220   if(ThreadLocalStorage::Created())
 221   {
 222     ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 223     tls->RemoveScene(this);
 224   }
 225 }
 226
 227 void Scene::RequestRebuildDepthTree()
 228 {
 229   mDepthTreeDirty = true;
 230 }
 231
 232 void Scene::QueueEvent(const Integration::Event& event)
 233 {
 234   mEventProcessor.QueueEvent(event);
 235 }
 236
 237 void Scene::ProcessEvents()
 238 {
 239   mEventProcessor.ProcessEvents();
 240 }
 241
 242 void Scene::RebuildDepthTree()
 243 {
 244   // If the depth tree needs rebuilding, do it in this frame only.
 245   if(mDepthTreeDirty)
 246   {
 247     ActorPtr actor(mRootLayer.Get());
 248     actor->RebuildDepthTree();
 249     mDepthTreeDirty = false;
 250   }
 251 }
 252
 253 void Scene::SetBackgroundColor(const Vector4& color)
 254 {
 255   mBackgroundColor = color;
 256
 257   mRenderTaskList->GetTask(0u)->SetClearColor(color);
 258   mRenderTaskList->GetTask(0u)->SetClearEnabled(true);
 259 }
 260
 261 Vector4 Scene::GetBackgroundColor() const
 262 {
 263   return mBackgroundColor;
 264 }
 265
 266 SceneGraph::Scene* Scene::GetSceneObject() const
 267 {
 268   return mSceneObject;
 269 }
 270
 271 void Scene::EmitKeyEventSignal(const Dali::KeyEvent& event)
 272 {
 273   if(!mKeyEventSignal.Empty())
 274   {
 275     Dali::Integration::Scene handle(this);
 276     mKeyEventSignal.Emit(event);
 277   }
 278 }
 279
 280 void Scene::SurfaceRotated(float width, float height, int32_t orientation)
 281 {
 282   mSurfaceOrientation = orientation;
 283   ChangedSurface(width, height, orientation);
 284 }
 285
 286 int32_t Scene::GetCurrentSurfaceOrientation() const
 287 {
 288   return mSceneObject->GetSurfaceOrientation();
 289 }
 290
 291 const Rect<int32_t>& Scene::GetCurrentSurfaceRect() const
 292 {
 293   return mSceneObject->GetSurfaceRect();
 294 }
 295
 296 void Scene::ChangedSurface(float width, float height, int32_t orientation)
 297 {
 298   Rect<int32_t> newSize(0, 0, static_cast<int32_t>(width), static_cast<int32_t>(height)); // truncated
 299   mSize.width  = width;
 300   mSize.height = height;
 301
 302   // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
 303   mDefaultCamera->SetPerspectiveProjection(mSize);
 304   // Set the surface orientation to Default camera for window/screen rotation
 305   mDefaultCamera->RotateProjection(orientation);
 306
 307   mRootLayer->SetSize(width, height);
 308
 309   // Send the surface rectangle/orientation to SceneGraph::Scene for calculating glViewport/Scissor
 310   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 311   SetSurfaceRectMessage(tls->GetEventThreadServices(), *mSceneObject, newSize);
 312   SetSurfaceOrientationMessage(tls->GetEventThreadServices(), *mSceneObject, static_cast<int32_t>(orientation));
 313
 314   // set default render-task viewport parameters
 315   RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask(0u);
 316   defaultRenderTask->SetViewport(newSize);
 317 }
 318
 319 bool Scene::IsSurfaceRectChanged() const
 320 {
 321   return mSceneObject->IsSurfaceRectChanged();
 322 }
 323
 324 bool Scene::IsRotationCompletedAcknowledgementSet() const
 325 {
 326   return mSceneObject->IsRotationCompletedAcknowledgementSet();
 327 }
 328
 329 void Scene::SetRotationCompletedAcknowledgement()
 330 {
 331   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 332   SetRotationCompletedAcknowledgementMessage(tls->GetEventThreadServices(), *mSceneObject);
 333 }
 334
 335 void Scene::SetSurfaceRenderTarget(Graphics::RenderTarget* renderTarget)
 336 {
 337   // Send the surface render target to SceneGraph::Scene
 338   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 339   SetSurfaceRenderTargetMessage(tls->GetEventThreadServices(), *mSceneObject, renderTarget);
 340 }
 341
 342 bool Scene::EmitKeyEventGeneratedSignal(const Dali::KeyEvent& event)
 343 {
 344   // Emit the KeyEventGenerated signal when KeyEvent is generated
 345   Dali::Integration::Scene handle(this);
 346   return mKeyEventGeneratedSignal.Emit(event);
 347 }
 348
 349 void Scene::EmitEventProcessingFinishedSignal()
 350 {
 351   if(!mEventProcessingFinishedSignal.Empty())
 352   {
 353     Dali::Integration::Scene handle(this);
 354     mEventProcessingFinishedSignal.Emit();
 355   }
 356 }
 357
 358 void Scene::EmitTouchedSignal(const Dali::TouchEvent& touch)
 359 {
 360   Dali::Integration::Scene handle(this);
 361   if(!mTouchedSignal.Empty())
 362   {
 363     mTouchedSignal.Emit(touch);
 364   }
 365 }
 366
 367 void Scene::EmitWheelEventSignal(const Dali::WheelEvent& event)
 368 {
 369   if(!mWheelEventSignal.Empty())
 370   {
 371     Dali::Integration::Scene handle(this);
 372     mWheelEventSignal.Emit(event);
 373   }
 374 }
 375
 376 void Scene::AddFrameRenderedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId)
 377 {
 378   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 379   AddFrameRenderedCallbackMessage(tls->GetEventThreadServices(), *mSceneObject, callback.release(), frameId);
 380 }
 381
 382 void Scene::AddFramePresentedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId)
 383 {
 384   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 385   AddFramePresentedCallbackMessage(tls->GetEventThreadServices(), *mSceneObject, callback.release(), frameId);
 386 }
 387
 388 void Scene::GetFrameRenderedCallback(Dali::Integration::Scene::FrameCallbackContainer& callbacks)
 389 {
 390   mSceneObject->GetFrameRenderedCallback(callbacks);
 391 }
 392
 393 void Scene::GetFramePresentedCallback(Dali::Integration::Scene::FrameCallbackContainer& callbacks)
 394 {
 395   mSceneObject->GetFramePresentedCallback(callbacks);
 396 }
 397
 398 Integration::Scene::KeyEventSignalType& Scene::KeyEventSignal()
 399 {
 400   return mKeyEventSignal;
 401 }
 402
 403 Integration::Scene::KeyEventGeneratedSignalType& Scene::KeyEventGeneratedSignal()
 404 {
 405   return mKeyEventGeneratedSignal;
 406 }
 407
 408 Integration::Scene::EventProcessingFinishedSignalType& Scene::EventProcessingFinishedSignal()
 409 {
 410   return mEventProcessingFinishedSignal;
 411 }
 412
 413 Integration::Scene::TouchEventSignalType& Scene::TouchedSignal()
 414 {
 415   return mTouchedSignal;
 416 }
 417
 418 Integration::Scene::WheelEventSignalType& Scene::WheelEventSignal()
 419 {
 420   return mWheelEventSignal;
 421 }
 422
 423 } // namespace Internal
 424
 425 } // namespace Dali