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

   1 #ifndef DALI_INTERNAL_SCENE_H
   2 #define DALI_INTERNAL_SCENE_H
   3
   4 /*
   5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/integration-api/scene.h>
  23 #include <dali/internal/common/owner-pointer.h>
  24 #include <dali/internal/event/actors/layer-impl.h>
  25 #include <dali/internal/event/events/event-processor.h>
  26 #include <dali/internal/event/render-tasks/render-task-defaults.h>
  27 #include <dali/public-api/actors/layer.h>
  28 #include <dali/public-api/math/vector2.h>
  29 #include <dali/public-api/render-tasks/render-task-list.h>
  30
  31 namespace Dali
  32 {
  33 namespace Integration
  34 {
  35 struct Event;
  36
  37 }
  38
  39 namespace Internal
  40 {
  41 //@todo Break this dependence somehow.
  42 namespace Render
  43 {
  44 class Renderer;
  45 }
  46
  47 namespace SceneGraph
  48 {
  49 class Scene;
  50
  51 struct DirtyRect
  52 {
  53   DirtyRect(Node* node, Render::Renderer* renderer, int32_t frame, Rect<int>& rect)
  54   : node(node),
  55     renderer(renderer),
  56     frame(frame),
  57     rect(rect),
  58     visited(true)
  59   {
  60   }
  61
  62   DirtyRect()
  63   : node(nullptr),
  64     renderer(nullptr),
  65     frame(0),
  66     rect(),
  67     visited(true)
  68   {
  69   }
  70
  71   bool operator<(const DirtyRect& rhs) const
  72   {
  73     if(node == rhs.node)
  74     {
  75       if(renderer == rhs.renderer)
  76       {
  77         return frame > rhs.frame; // Most recent rects come first
  78       }
  79       else
  80       {
  81         return renderer < rhs.renderer;
  82       }
  83     }
  84     else
  85     {
  86       return node < rhs.node;
  87     }
  88   }
  89
  90   Node*             node;
  91   Render::Renderer* renderer;
  92   int32_t           frame;
  93
  94   Rect<int32_t> rect;
  95   bool          visited;
  96 };
  97
  98 } // namespace SceneGraph
  99
 100 class EventProcessor;
 101 class Layer;
 102 class LayerList;
 103 class CameraActor;
 104 class RenderTaskList;
 105 class FrameBuffer;
 106
 107 using FrameBufferPtr = IntrusivePtr<FrameBuffer>;
 108 using ScenePtr       = IntrusivePtr<Scene>;
 109
 110 /**
 111  * @brief Scene creates a "world" that can be bound to a surface for rendering.
 112  */
 113 class Scene : public BaseObject, public RenderTaskDefaults
 114 {
 115 public:
 116   /**
 117    * @copydoc Dali::Integration::Scene::New
 118    */
 119   static ScenePtr New(Size size, int32_t orientation = 0);
 120
 121   /**
 122    * virtual destructor
 123    */
 124   ~Scene() override;
 125
 126   /**
 127    * @copydoc Dali::Integration::Scene::Add
 128    */
 129   void Add(Actor& actor);
 130
 131   /**
 132    * @copydoc Dali::Integration::Scene::Remove
 133    */
 134   void Remove(Actor& actor);
 135
 136   /**
 137    * @copydoc Dali::Integration::Scene::GetSize
 138    */
 139   Size GetSize() const;
 140
 141   /**
 142    * @copydoc Dali::Integration::Scene::SetDpi
 143    */
 144   void SetDpi(Vector2 dpi);
 145
 146   /**
 147    * @copydoc Dali::Integration::Scene::GetDpi
 148    */
 149   Vector2 GetDpi() const;
 150
 151   /**
 152    * @copydoc Dali::Integration::Scene::GetRenderTaskList
 153    */
 154   RenderTaskList& GetRenderTaskList() const;
 155
 156   /**
 157    * @copydoc Dali::Integration::Scene::GetRootLayer
 158    */
 159   Dali::Layer GetRootLayer() const;
 160
 161   /**
 162    * @copydoc Dali::Integration::Scene::GetLayerCount
 163    */
 164   uint32_t GetLayerCount() const;
 165
 166   /**
 167    * @copydoc Dali::Integration::Scene::GetLayer
 168    */
 169   Dali::Layer GetLayer(uint32_t depth) const;
 170
 171   /**
 172    * Notify the surface has been resized.
 173    *
 174    * @param[in] width The new width of the set surface
 175    * @param[in] height The new height of the set surface
 176    */
 177   void SurfaceResized(float width, float height);
 178
 179   /**
 180    * @copydoc Dali::Integration::Scene::SurfaceReplaced
 181    */
 182   void SurfaceReplaced();
 183
 184   /**
 185    * @copydoc Dali::Integration::Scene::Discard
 186    */
 187   void Discard();
 188
 189   /**
 190    * Retrieve the ordered list of on-scene layers.
 191    * @return The layer-list.
 192    */
 193   LayerList& GetLayerList() const;
 194
 195   /**
 196    * Request that the depth tree is rebuilt
 197    */
 198   void RequestRebuildDepthTree();
 199
 200   /**
 201    * This function is called when an event is queued.
 202    * @param[in] event A event to queue.
 203    */
 204   void QueueEvent(const Integration::Event& event);
 205
 206   /**
 207    * This function is called by Core when events are processed.
 208    */
 209   void ProcessEvents();
 210
 211   /**
 212    * Rebuilds the depth tree at the end of the event frame if
 213    * it was requested this frame.
 214    */
 215   void RebuildDepthTree();
 216
 217   /**
 218    * @brief Sets the background color of the render surface.
 219    * @param[in] color The new background color
 220    */
 221   void SetBackgroundColor(const Vector4& color);
 222
 223   /**
 224    * @brief Gets the background color of the render　surface.
 225    * @return The background color
 226    */
 227   Vector4 GetBackgroundColor() const;
 228
 229   /**
 230    * @brief Get the Scene scene graph object
 231    *
 232    * @return the Scene scene graph object
 233    */
 234   SceneGraph::Scene* GetSceneObject() const;
 235
 236   /**
 237    * Notify the surface has been rotated.
 238    * When the device is rotated or the rotation event is received by display manager,
 239    * this function will be called by window implementation.
 240    *
 241    * @param[in] width The width of rotated surface
 242    * @param[in] height The height of rotated surface
 243    * @param[in] orientation The orientation of rotated surface
 244    */
 245   void SurfaceRotated(float width, float height, int32_t orientation);
 246
 247   /**
 248    * @copydoc Dali::Integration::Scene::GetCurrentSurfaceOrientation
 249    */
 250   int32_t GetCurrentSurfaceOrientation() const;
 251
 252   /**
 253    * @copydoc Dali::Integration::Scene::GetCurrentSurfaceRect
 254    */
 255   const Rect<int32_t>& GetCurrentSurfaceRect() const;
 256
 257   /**
 258    * @copydoc Dali::Integration::Scene::IsSurfaceRectChanged
 259    */
 260   bool IsSurfaceRectChanged() const;
 261
 262   /**
 263    * Used by the EventProcessor to emit key event signals.
 264    * @param[in] event The key event.
 265    */
 266   void EmitKeyEventSignal(const Dali::KeyEvent& event);
 267
 268   /**
 269    * Used by the KeyEventProcessor to emit KeyEventGenerated signals.
 270    * @param[in] event The key event.
 271    * @return The return is true if KeyEvent is consumed, otherwise false.
 272    */
 273   bool EmitKeyEventGeneratedSignal(const Dali::KeyEvent& event);
 274
 275   /**
 276    * Emits the event processing finished signal.
 277    *
 278    * @see Dali::Scene::SignalEventProcessingFinished()
 279    */
 280   void EmitEventProcessingFinishedSignal();
 281
 282   /**
 283    * Emits the touched signal.
 284    * @param[in] touch The touch event details.
 285    */
 286   void EmitTouchedSignal(const Dali::TouchEvent& touch);
 287
 288   /**
 289    * Used by the EventProcessor to emit wheel event signals.
 290    * @param[in] event The wheel event.
 291    */
 292   void EmitWheelEventSignal(const Dali::WheelEvent& event);
 293
 294   /**
 295    * @copydoc Dali::Integration::Scene::AddFrameRenderedCallback
 296    */
 297   void AddFrameRenderedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId);
 298
 299   /**
 300    * @copydoc Dali::Integration::Scene::AddFramePresentedCallback
 301    */
 302   void AddFramePresentedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId);
 303
 304   /**
 305    * @copydoc Dali::Integration::Scene::GetFrameRenderedCallback
 306    */
 307   void GetFrameRenderedCallback(Dali::Integration::Scene::FrameCallbackContainer& callbacks);
 308
 309   /**
 310    * @copydoc Dali::Integration::Scene::GetFramePresentedCallback
 311    */
 312   void GetFramePresentedCallback(Dali::Integration::Scene::FrameCallbackContainer& callbacks);
 313
 314   /**
 315    * @copydoc Integration::Scene::KeyEventSignal()
 316    */
 317   Integration::Scene::KeyEventSignalType& KeyEventSignal();
 318
 319   /**
 320    * @copydoc Integration::Scene::KeyEventGeneratedSignal()
 321    */
 322   Integration::Scene::KeyEventGeneratedSignalType& KeyEventGeneratedSignal();
 323
 324   /**
 325    * @copydoc Integration::Scene::SignalEventProcessingFinished()
 326    */
 327   Integration::Scene::EventProcessingFinishedSignalType& EventProcessingFinishedSignal();
 328
 329   /**
 330     * @copydoc Integration::Scene::TouchedSignal()
 331     */
 332   Integration::Scene::TouchEventSignalType& TouchedSignal();
 333
 334   /**
 335    * @copydoc Integration::Scene::sWheelEventSignal()
 336    */
 337   Integration::Scene::WheelEventSignalType& WheelEventSignal();
 338
 339   /**
 340    * @brief Get ItemsDirtyRects
 341    *
 342    * @return the ItemsDirtyRects
 343    */
 344   std::vector<Dali::Internal::SceneGraph::DirtyRect>& GetItemsDirtyRects();
 345
 346 public:
 347   /**
 348    * From RenderTaskDefaults; retrieve the default root actor.
 349    * @return The default root actor.
 350    */
 351   Actor& GetDefaultRootActor() override;
 352
 353   /**
 354    * From RenderTaskDefaults; retrieve the default camera actor.
 355    * @return The default camera actor.
 356    */
 357   CameraActor& GetDefaultCameraActor() override;
 358
 359 private:
 360   // Constructor
 361   Scene();
 362
 363   /**
 364    * Second-phase constructor.
 365    *
 366    * @param[in] size The size of the set surface
 367    * @param[in] orientation The orientation of the set surface for this scene
 368    */
 369   void Initialize(Size size, int32_t orientation);
 370
 371   // Undefined
 372   Scene(const Scene&) = delete;
 373
 374   // Undefined
 375   Scene& operator=(const Scene& rhs) = delete;
 376
 377   /**
 378    * Informs the scene that the set surface has been resized or rotated.
 379    *
 380    * @param[in] width The width of rotated surface
 381    * @param[in] height The height of rotated surface
 382    * @param[in] orientation The orientation of rotated surface
 383    */
 384   void ChangedSurface(float width, float height, int32_t orientation);
 385
 386 private:
 387   Internal::SceneGraph::Scene* mSceneObject;
 388
 389   Size mSize;
 390
 391   Vector2 mDpi;
 392
 393   Vector4 mBackgroundColor;
 394
 395   LayerPtr mRootLayer;
 396
 397   // Ordered list of currently on-stage layers
 398   OwnerPointer<LayerList> mLayerList;
 399
 400   IntrusivePtr<CameraActor> mDefaultCamera;
 401
 402   // The list of render-tasks
 403   IntrusivePtr<RenderTaskList> mRenderTaskList;
 404
 405   bool mDepthTreeDirty : 1; ///< True if the depth tree needs recalculating
 406
 407   EventProcessor mEventProcessor;
 408
 409   // The Surface's orientation
 410   int32_t mSurfaceOrientation;
 411
 412   // The key event signal
 413   Integration::Scene::KeyEventSignalType          mKeyEventSignal;
 414   Integration::Scene::KeyEventGeneratedSignalType mKeyEventGeneratedSignal;
 415
 416   // The event processing finished signal
 417   Integration::Scene::EventProcessingFinishedSignalType mEventProcessingFinishedSignal;
 418
 419   // The touch signal
 420   Integration::Scene::TouchEventSignalType mTouchedSignal;
 421
 422   // The wheel event signal
 423   Integration::Scene::WheelEventSignalType mWheelEventSignal;
 424
 425   std::vector<Dali::Internal::SceneGraph::DirtyRect> mItemsDirtyRects;
 426 };
 427
 428 } // namespace Internal
 429
 430 // Get impl of handle
 431 inline Internal::Scene& GetImplementation(Dali::Integration::Scene& scene)
 432 {
 433   DALI_ASSERT_ALWAYS(scene && "Scene handle is empty");
 434   Dali::RefObject& object = scene.GetBaseObject();
 435   return static_cast<Internal::Scene&>(object);
 436 }
 437
 438 inline const Internal::Scene& GetImplementation(const Dali::Integration::Scene& scene)
 439 {
 440   DALI_ASSERT_ALWAYS(scene && "Scene handle is empty");
 441   const Dali::RefObject& object = scene.GetBaseObject();
 442   return static_cast<const Internal::Scene&>(object);
 443 }
 444
 445 } // namespace Dali
 446
 447 #endif // DALI_INTERNAL_SCENE_H