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

   1 /*
   2  * Copyright (c) 2023 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 windowOrientation, int32_t screenOrientation)
  45 {
  46   ScenePtr scene = new Scene;
  47
  48   // Second-phase construction
  49   scene->Initialize(size, windowOrientation, screenOrientation);
  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   mPartialUpdateEnabled(true),
  61   mGeometryHittest(false),
  62   mEventProcessor(*this, ThreadLocalStorage::GetInternal()->GetGestureEventProcessor()),
  63   mSurfaceOrientation(0),
  64   mScreenOrientation(0),
  65   mNativeId(0)
  66 {
  67 }
  68
  69 Scene::~Scene()
  70 {
  71   if(mDefaultCamera)
  72   {
  73     // its enough to release the handle so the object is released
  74     // don't need to remove it from root actor as root actor will delete the object
  75     mDefaultCamera.Reset();
  76   }
  77
  78   if(mRootLayer)
  79   {
  80     // we are closing down so just delete the root, no point emit disconnect
  81     // signals or send messages to update
  82     mRootLayer.Reset();
  83   }
  84
  85   if(mOverlayLayer)
  86   {
  87     mOverlayLayer.Reset();
  88   }
  89
  90   if(mRenderTaskList)
  91   {
  92     mRenderTaskList.Reset();
  93   }
  94
  95   // No need to discard this Scene from Core, as Core stores an intrusive_ptr to this scene
  96   // When this destructor is called, the scene has either already been removed from Core or Core has already been destroyed
  97 }
  98
  99 void Scene::Initialize(Size size, int32_t windowOrientation, int32_t screenOrientation)
 100 {
 101   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 102
 103   DALI_ASSERT_ALWAYS(tls && "Attempt to create scene before core exists!");
 104
 105   tls->AddScene(this);
 106
 107   SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager();
 108
 109   // Create the ordered list of layers
 110   mLayerList = LayerList::New(updateManager);
 111
 112   // The scene owns the default layer
 113   mRootLayer = Layer::NewRoot(*mLayerList);
 114   mRootLayer->SetName("RootLayer");
 115   mRootLayer->SetScene(*this);
 116
 117   // The root layer needs to have a fixed resize policy (as opposed to the default USE_NATURAL_SIZE).
 118   // This stops actors parented to the stage having their relayout requests propagating
 119   // up to the root layer, and down through other children unnecessarily.
 120   mRootLayer->SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
 121
 122   // Create the default camera actor first; this is needed by the RenderTaskList
 123   // The default camera attributes and position is such that children of the default layer,
 124   // can be positioned at (0,0) and be at the top-left of the viewport.
 125   mDefaultCamera = CameraActor::New(size);
 126   mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER);
 127   Add(*(mDefaultCamera.Get()));
 128
 129   // Create the list of render-tasks
 130   mRenderTaskList = RenderTaskList::New();
 131
 132   // Create the default render-task and ensure clear is enabled on it to show the background color
 133   RenderTaskPtr renderTask = mRenderTaskList->CreateTask(mRootLayer.Get(), mDefaultCamera.Get());
 134   renderTask->SetClearEnabled(true);
 135
 136   // Create scene graph object
 137   mSceneObject = new SceneGraph::Scene();
 138   OwnerPointer<SceneGraph::Scene> transferOwnership(const_cast<SceneGraph::Scene*>(mSceneObject));
 139   AddSceneMessage(updateManager, transferOwnership);
 140
 141   SurfaceRotated(size.width, size.height, windowOrientation, screenOrientation);
 142 }
 143
 144 void Scene::Add(Actor& actor)
 145 {
 146   mRootLayer->Add(actor);
 147 }
 148
 149 void Scene::Remove(Actor& actor)
 150 {
 151   mRootLayer->Remove(actor);
 152 }
 153
 154 Size Scene::GetSize() const
 155 {
 156   return mSize;
 157 }
 158
 159 void Scene::SetDpi(Vector2 dpi)
 160 {
 161   mDpi = dpi;
 162 }
 163
 164 Vector2 Scene::GetDpi() const
 165 {
 166   return mDpi;
 167 }
 168
 169 RenderTaskList& Scene::GetRenderTaskList() const
 170 {
 171   return *mRenderTaskList;
 172 }
 173
 174 Dali::Layer Scene::GetRootLayer() const
 175 {
 176   return Dali::Layer(mRootLayer.Get());
 177 }
 178
 179 Dali::Layer Scene::GetOverlayLayer()
 180 {
 181   if(!mOverlayLayer)
 182   {
 183     // Creates overlay layer.
 184     mOverlayLayer = Layer::New();
 185     mOverlayLayer->SetName("OverlayLayer");
 186     mOverlayLayer->SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
 187     mOverlayLayer->SetParentOrigin(Dali::ParentOrigin::TOP_LEFT);
 188     mOverlayLayer->SetAnchorPoint(Dali::AnchorPoint::TOP_LEFT);
 189     mRootLayer->Add(*mOverlayLayer);
 190
 191     // Create the overlay render-task and set exclusive to true.
 192     RenderTaskPtr renderTask = mRenderTaskList->CreateOverlayTask(mOverlayLayer.Get(), mDefaultCamera.Get());
 193     renderTask->SetExclusive(true);
 194     renderTask->SetInputEnabled(true);
 195   }
 196   return Dali::Layer(mOverlayLayer.Get());
 197 }
 198
 199 LayerList& Scene::GetLayerList() const
 200 {
 201   return *mLayerList;
 202 }
 203
 204 uint32_t Scene::GetLayerCount() const
 205 {
 206   return mLayerList->GetLayerCount();
 207 }
 208
 209 Dali::Layer Scene::GetLayer(uint32_t depth) const
 210 {
 211   return Dali::Layer(mLayerList->GetLayer(depth));
 212 }
 213
 214 CameraActor& Scene::GetDefaultCameraActor() const
 215 {
 216   return *mDefaultCamera;
 217 }
 218
 219 Actor& Scene::GetDefaultRootActor()
 220 {
 221   return *mRootLayer;
 222 }
 223
 224 void Scene::SurfaceResized(float width, float height)
 225 {
 226   if((fabsf(mSize.width - width) > Math::MACHINE_EPSILON_1) || (fabsf(mSize.height - height) > Math::MACHINE_EPSILON_1))
 227   {
 228     ChangedSurface(width, height, mSurfaceOrientation, mScreenOrientation);
 229   }
 230 }
 231
 232 void Scene::SurfaceReplaced()
 233 {
 234   if(mSceneObject)
 235   {
 236     ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 237     SurfaceReplacedMessage(tls->GetUpdateManager(), *mSceneObject);
 238   }
 239 }
 240
 241 void Scene::RemoveSceneObject()
 242 {
 243   if(EventThreadServices::IsCoreRunning() && mSceneObject)
 244   {
 245     ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 246     RemoveSceneMessage(tls->GetUpdateManager(), *mSceneObject);
 247     mSceneObject = nullptr;
 248   }
 249 }
 250
 251 void Scene::Discard()
 252 {
 253   if(EventThreadServices::IsCoreRunning())
 254   {
 255     ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 256     tls->RemoveScene(this);
 257   }
 258 }
 259
 260 void Scene::RequestRebuildDepthTree()
 261 {
 262   mDepthTreeDirty = true;
 263 }
 264
 265 void Scene::QueueEvent(const Integration::Event& event)
 266 {
 267   mEventProcessor.QueueEvent(event);
 268 }
 269
 270 void Scene::ProcessEvents()
 271 {
 272   mEventProcessor.ProcessEvents();
 273 }
 274
 275 void Scene::SendInterruptedEvents(Dali::Internal::Actor* actor)
 276 {
 277   mEventProcessor.SendInterruptedEvents(actor);
 278 }
 279
 280 void Scene::RebuildDepthTree()
 281 {
 282   // If the depth tree needs rebuilding, do it in this frame only.
 283   if(mDepthTreeDirty)
 284   {
 285     ActorPtr actor(mRootLayer.Get());
 286     actor->RebuildDepthTree();
 287     mDepthTreeDirty = false;
 288   }
 289   mRenderTaskList->SortTasks();
 290 }
 291
 292 void Scene::SetBackgroundColor(const Vector4& color)
 293 {
 294   mBackgroundColor = color;
 295
 296   mRenderTaskList->GetTask(0u)->SetClearColor(color);
 297   mRenderTaskList->GetTask(0u)->SetClearEnabled(true);
 298 }
 299
 300 Vector4 Scene::GetBackgroundColor() const
 301 {
 302   return mBackgroundColor;
 303 }
 304
 305 SceneGraph::Scene* Scene::GetSceneObject() const
 306 {
 307   return mSceneObject;
 308 }
 309
 310 void Scene::EmitKeyEventSignal(const Dali::KeyEvent& event)
 311 {
 312   if(!mKeyEventSignal.Empty())
 313   {
 314     Dali::Integration::Scene handle(this);
 315     mKeyEventSignal.Emit(event);
 316   }
 317 }
 318
 319 void Scene::SurfaceRotated(float width, float height, int32_t windowOrientation, int32_t screenOrientation)
 320 {
 321   ChangedSurface(width, height, windowOrientation, screenOrientation);
 322 }
 323
 324 int32_t Scene::GetCurrentSurfaceOrientation() const
 325 {
 326   return mSceneObject ? mSceneObject->GetSurfaceOrientation() : 0;
 327 }
 328
 329 int32_t Scene::GetCurrentScreenOrientation() const
 330 {
 331   return mSceneObject ? mSceneObject->GetScreenOrientation() : 0;
 332 }
 333
 334 const Rect<int32_t>& Scene::GetCurrentSurfaceRect() const
 335 {
 336   static Rect<int32_t> emptyRect{};
 337   return mSceneObject ? mSceneObject->GetSurfaceRect() : emptyRect;
 338 }
 339
 340 void Scene::ChangedSurface(float width, float height, int32_t windowOrientation, int32_t screenOrientation)
 341 {
 342   bool          changedOrientation = false;
 343   Rect<int32_t> newSize(0, 0, static_cast<int32_t>(width), static_cast<int32_t>(height)); // truncated
 344   mSize.width  = width;
 345   mSize.height = height;
 346
 347   if(mSurfaceOrientation != windowOrientation || mScreenOrientation != screenOrientation)
 348   {
 349     changedOrientation = true;
 350   }
 351
 352   mSurfaceOrientation = windowOrientation;
 353   mScreenOrientation  = screenOrientation;
 354
 355   // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
 356   mDefaultCamera->SetPerspectiveProjection(mSize);
 357   // Set the surface orientation to Default camera for window/screen rotation
 358   if(changedOrientation)
 359   {
 360     int32_t orientation = (windowOrientation + screenOrientation) % 360;
 361     mDefaultCamera->RotateProjection(orientation);
 362   }
 363
 364   mRootLayer->SetSize(width, height);
 365
 366   // Send the surface rectangle/orientation to SceneGraph::Scene for calculating glViewport/Scissor
 367   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 368   DALI_LOG_RELEASE_INFO("Send Surface Rect Message, width[%d], height[%d]\n", newSize.width, newSize.height);
 369   SetSurfaceRectMessage(tls->GetEventThreadServices(), *mSceneObject, newSize);
 370   if(changedOrientation)
 371   {
 372     DALI_LOG_RELEASE_INFO("Send Surface Orientation Message, surface orientation[%d], screen orientation[%d]\n", mSurfaceOrientation, mScreenOrientation);
 373     SetSurfaceOrientationsMessage(tls->GetEventThreadServices(), *mSceneObject, mSurfaceOrientation, mScreenOrientation);
 374   }
 375
 376   // set default render-task viewport parameters
 377   RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask(0u);
 378   defaultRenderTask->SetViewport(newSize);
 379   // set overlay render-task viewport parameters
 380   RenderTaskPtr overlayRenderTask = mRenderTaskList->GetOverlayTask();
 381   if(overlayRenderTask)
 382   {
 383     overlayRenderTask->SetViewport(newSize);
 384   }
 385 }
 386
 387 uint32_t Scene::GetSurfaceRectChangedCount() const
 388 {
 389   return mSceneObject ? mSceneObject->GetSurfaceRectChangedCount() : 0u;
 390 }
 391
 392 bool Scene::IsRotationCompletedAcknowledgementSet() const
 393 {
 394   return mSceneObject ? mSceneObject->IsRotationCompletedAcknowledgementSet() : false;
 395 }
 396
 397 void Scene::SetRotationCompletedAcknowledgement()
 398 {
 399   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 400   SetRotationCompletedAcknowledgementMessage(tls->GetEventThreadServices(), *mSceneObject);
 401 }
 402
 403 void Scene::SetSurfaceRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo)
 404 {
 405   // Send the surface render target to SceneGraph::Scene
 406   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 407   SetSurfaceRenderTargetCreateInfoMessage(tls->GetEventThreadServices(), *mSceneObject, renderTargetCreateInfo);
 408 }
 409
 410 bool Scene::EmitKeyEventGeneratedSignal(const Dali::KeyEvent& event)
 411 {
 412   // Emit the KeyEventGenerated signal when KeyEvent is generated
 413   Dali::Integration::Scene handle(this);
 414   return mKeyEventGeneratedSignal.Emit(event);
 415 }
 416
 417 bool Scene::EmitInterceptKeyEventSignal(const Dali::KeyEvent& event)
 418 {
 419   // Emit the InterceptKeyEvent signal
 420   Dali::Integration::Scene handle(this);
 421   return mInterceptKeyEventSignal.Emit(event);
 422 }
 423
 424 void Scene::EmitEventProcessingFinishedSignal()
 425 {
 426   if(!mEventProcessingFinishedSignal.Empty())
 427   {
 428     Dali::Integration::Scene handle(this);
 429     mEventProcessingFinishedSignal.Emit();
 430   }
 431 }
 432
 433 void Scene::EmitTouchedSignal(const Dali::TouchEvent& touch)
 434 {
 435   Dali::Integration::Scene handle(this);
 436   if(!mTouchedSignal.Empty())
 437   {
 438     mTouchedSignal.Emit(touch);
 439   }
 440 }
 441
 442 void Scene::EmitWheelEventSignal(const Dali::WheelEvent& event)
 443 {
 444   if(!mWheelEventSignal.Empty())
 445   {
 446     Dali::Integration::Scene handle(this);
 447     mWheelEventSignal.Emit(event);
 448   }
 449 }
 450
 451 bool Scene::EmitWheelEventGeneratedSignal(const Dali::WheelEvent& event)
 452 {
 453   // Emit the WheelEventGenerated signal when WheelEvent is generated
 454   Dali::Integration::Scene handle(this);
 455   return mWheelEventGeneratedSignal.Emit(event);
 456 }
 457
 458 void Scene::AddFrameRenderedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId)
 459 {
 460   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 461   AddFrameRenderedCallbackMessage(tls->GetEventThreadServices(), *mSceneObject, callback.release(), frameId);
 462 }
 463
 464 void Scene::AddFramePresentedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId)
 465 {
 466   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 467   AddFramePresentedCallbackMessage(tls->GetEventThreadServices(), *mSceneObject, callback.release(), frameId);
 468 }
 469
 470 void Scene::GetFrameRenderedCallback(Dali::Integration::Scene::FrameCallbackContainer& callbacks)
 471 {
 472   if(mSceneObject)
 473   {
 474     mSceneObject->GetFrameRenderedCallback(callbacks);
 475   }
 476 }
 477
 478 void Scene::GetFramePresentedCallback(Dali::Integration::Scene::FrameCallbackContainer& callbacks)
 479 {
 480   if(mSceneObject)
 481   {
 482     mSceneObject->GetFramePresentedCallback(callbacks);
 483   }
 484 }
 485
 486 void Scene::KeepRendering(float durationSeconds)
 487 {
 488   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 489   KeepRenderingMessage(tls->GetEventThreadServices(), *mSceneObject, durationSeconds);
 490 }
 491
 492 void Scene::SetPartialUpdateEnabled(bool enabled)
 493 {
 494   mPartialUpdateEnabled = enabled;
 495
 496   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 497   SetPartialUpdateEnabledMessage(tls->GetEventThreadServices(), *mSceneObject, enabled);
 498 }
 499
 500 bool Scene::IsPartialUpdateEnabled() const
 501 {
 502   return mPartialUpdateEnabled;
 503 }
 504
 505 void Scene::SetGeometryHittestEnabled(bool enabled)
 506 {
 507   mGeometryHittest = enabled;
 508 }
 509
 510 bool Scene::IsGeometryHittestEnabled() const
 511 {
 512   return mGeometryHittest;
 513 }
 514
 515 void Scene::SetNativeId(int32_t nativeId)
 516 {
 517   mNativeId = nativeId;
 518 }
 519
 520 int32_t Scene::GetNativeId() const
 521 {
 522   return mNativeId;
 523 }
 524
 525 Integration::Scene::KeyEventSignalType& Scene::KeyEventSignal()
 526 {
 527   return mKeyEventSignal;
 528 }
 529
 530 Integration::Scene::KeyEventGeneratedSignalType& Scene::KeyEventGeneratedSignal()
 531 {
 532   return mKeyEventGeneratedSignal;
 533 }
 534
 535 Integration::Scene::KeyEventGeneratedSignalType& Scene::InterceptKeyEventSignal()
 536 {
 537   return mInterceptKeyEventSignal;
 538 }
 539
 540 Integration::Scene::EventProcessingFinishedSignalType& Scene::EventProcessingFinishedSignal()
 541 {
 542   return mEventProcessingFinishedSignal;
 543 }
 544
 545 Integration::Scene::TouchEventSignalType& Scene::TouchedSignal()
 546 {
 547   return mTouchedSignal;
 548 }
 549
 550 Integration::Scene::WheelEventSignalType& Scene::WheelEventSignal()
 551 {
 552   return mWheelEventSignal;
 553 }
 554
 555 Integration::Scene::WheelEventGeneratedSignalType& Scene::WheelEventGeneratedSignal()
 556 {
 557   return mWheelEventGeneratedSignal;
 558 }
 559
 560 } // namespace Internal
 561
 562 } // namespace Dali