#define DALI_INTERNAL_SCENE_H
/*
- * Copyright (c) 2020 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.
// INTERNAL INCLUDES
#include <dali/integration-api/scene.h>
-#include <dali/public-api/math/vector2.h>
-#include <dali/public-api/actors/layer.h>
-#include <dali/public-api/render-tasks/render-task-list.h>
#include <dali/internal/common/owner-pointer.h>
#include <dali/internal/event/actors/layer-impl.h>
#include <dali/internal/event/events/event-processor.h>
#include <dali/internal/event/render-tasks/render-task-defaults.h>
+#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/math/vector2.h>
+#include <dali/public-api/render-tasks/render-task-list.h>
namespace Dali
{
-
namespace Integration
{
-
struct Event;
}
namespace Internal
{
-
namespace SceneGraph
{
class Scene;
-
-struct DirtyRect
-{
- DirtyRect(Node* node, Render::Renderer* renderer, int frame, Rect<int>& rect)
- : node(node),
- renderer(renderer),
- frame(frame),
- rect(rect),
- visited(true)
- {
- }
-
- DirtyRect()
- : node(nullptr),
- renderer(nullptr),
- frame(0),
- rect(),
- visited(true)
- {
- }
-
- bool operator<(const DirtyRect& rhs) const
- {
- if (node == rhs.node)
- {
- if (renderer == rhs.renderer)
- {
- return frame > rhs.frame; // Most recent rects come first
- }
- else
- {
- return renderer < rhs.renderer;
- }
- }
- else
- {
- return node < rhs.node;
- }
- }
-
- Node* node;
- Render::Renderer* renderer;
- int frame;
-
- Rect<int> rect;
- bool visited;
-};
-
-}
+} // namespace SceneGraph
class EventProcessor;
class Layer;
class FrameBuffer;
using FrameBufferPtr = IntrusivePtr<FrameBuffer>;
-using ScenePtr = IntrusivePtr<Scene>;
+using ScenePtr = IntrusivePtr<Scene>;
/**
* @brief Scene creates a "world" that can be bound to a surface for rendering.
*/
class Scene : public BaseObject, public RenderTaskDefaults
{
-
public:
/**
* @copydoc Dali::Integration::Scene::New
*/
- static ScenePtr New( Size size );
+ static ScenePtr New(Size size, int32_t orientation = 0);
/**
* virtual destructor
*/
- virtual ~Scene();
+ ~Scene() override;
/**
* @copydoc Dali::Integration::Scene::Add
/**
* @copydoc Dali::Integration::Scene::SetDpi
*/
- void SetDpi( Vector2 dpi );
+ void SetDpi(Vector2 dpi);
/**
* @copydoc Dali::Integration::Scene::GetDpi
*
* @param[in] width The new width of the set surface
* @param[in] height The new height of the set surface
- * @param[in] orientation The orientation of the surface
- * @param[in] forceUpdate The flag to update force
*/
- void SurfaceResized( float width, float height, int orientation, bool forceUpdate );
+ void SurfaceResized(float width, float height);
/**
* @copydoc Dali::Integration::Scene::SurfaceReplaced
* This function is called when an event is queued.
* @param[in] event A event to queue.
*/
- void QueueEvent( const Integration::Event& event );
+ void QueueEvent(const Integration::Event& event);
/**
* This function is called by Core when events are processed.
* @brief Sets the background color of the render surface.
* @param[in] color The new background color
*/
- void SetBackgroundColor( const Vector4& color );
+ void SetBackgroundColor(const Vector4& color);
/**
* @brief Gets the background color of the render surface.
SceneGraph::Scene* GetSceneObject() const;
/**
+ * Notify the surface has been rotated.
+ * When the device is rotated or the rotation event is received by display manager,
+ * this function will be called by window implementation.
+ *
+ * @param[in] width The width of rotated surface
+ * @param[in] height The height of rotated surface
+ * @param[in] orientation The orientation of rotated surface
+ */
+ void SurfaceRotated(float width, float height, int32_t orientation);
+
+ /**
+ * @copydoc Dali::Integration::Scene::SetRotationCompletedAcknowledgement
+ */
+ void SetRotationCompletedAcknowledgement();
+
+ /**
+ * @copydoc Dali::Integration::Scene::IsRotationCompletedAcknowledgementSet
+ */
+ bool IsRotationCompletedAcknowledgementSet() const;
+
+ /**
+ * @copydoc Dali::Integration::Scene::GetCurrentSurfaceOrientation
+ */
+ int32_t GetCurrentSurfaceOrientation() const;
+
+ /**
+ * @copydoc Dali::Integration::Scene::GetCurrentSurfaceRect
+ */
+ const Rect<int32_t>& GetCurrentSurfaceRect() const;
+
+ /**
+ * @copydoc Dali::Integration::Scene::IsSurfaceRectChanged
+ */
+ bool IsSurfaceRectChanged() const;
+
+ /**
+ * @copydoc Dali::Integration::Scene::SetSurfaceRenderTarget
+ */
+ void SetSurfaceRenderTarget(Graphics::RenderTarget* renderTarget);
+
+ /**
* Used by the EventProcessor to emit key event signals.
* @param[in] event The key event.
*/
- void EmitKeyEventSignal(const KeyEvent& event);
+ void EmitKeyEventSignal(const Dali::KeyEvent& event);
/**
* Used by the KeyEventProcessor to emit KeyEventGenerated signals.
* @param[in] event The key event.
* @return The return is true if KeyEvent is consumed, otherwise false.
*/
- bool EmitKeyEventGeneratedSignal(const KeyEvent& event);
+ bool EmitKeyEventGeneratedSignal(const Dali::KeyEvent& event);
+
+ /**
+ * Used by the KeyEventProcessor to emit InterceptKeyEventSignal signals.
+ * @param[in] event The key event.
+ * @return The return is true if KeyEvent is consumed, otherwise false.
+ */
+ bool EmitInterceptKeyEventSignal(const Dali::KeyEvent& event);
/**
* Emits the event processing finished signal.
* Emits the touched signal.
* @param[in] touch The touch event details.
*/
- void EmitTouchedSignal( const Dali::TouchEvent& touch );
+ void EmitTouchedSignal(const Dali::TouchEvent& touch);
/**
* Used by the EventProcessor to emit wheel event signals.
* @param[in] event The wheel event.
*/
- void EmitWheelEventSignal( const WheelEvent& event );
+ void EmitWheelEventSignal(const Dali::WheelEvent& event);
+
+ /**
+ * Used by the WheelEventProcessor to emit WheelEventGenerated signals.
+ * @param[in] event The wheel event.
+ * @return The return is true if WheelEvent is consumed, otherwise false.
+ */
+ bool EmitWheelEventGeneratedSignal(const Dali::WheelEvent& event);
/**
* @copydoc Dali::Integration::Scene::AddFrameRenderedCallback
*/
- void AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+ void AddFrameRenderedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId);
/**
* @copydoc Dali::Integration::Scene::AddFramePresentedCallback
*/
- void AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+ void AddFramePresentedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId);
/**
* @copydoc Dali::Integration::Scene::GetFrameRenderedCallback
*/
- void GetFrameRenderedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks );
+ void GetFrameRenderedCallback(Dali::Integration::Scene::FrameCallbackContainer& callbacks);
/**
* @copydoc Dali::Integration::Scene::GetFramePresentedCallback
*/
- void GetFramePresentedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks );
+ void GetFramePresentedCallback(Dali::Integration::Scene::FrameCallbackContainer& callbacks);
/**
* @copydoc Integration::Scene::KeyEventSignal()
*/
Integration::Scene::KeyEventSignalType& KeyEventSignal();
- /**
+ /**
* @copydoc Integration::Scene::KeyEventGeneratedSignal()
*/
Integration::Scene::KeyEventGeneratedSignalType& KeyEventGeneratedSignal();
/**
+ * @copydoc Integration::Scene::InterceptKeyEventSignal()
+ */
+ Integration::Scene::KeyEventGeneratedSignalType& InterceptKeyEventSignal();
+
+ /**
* @copydoc Integration::Scene::SignalEventProcessingFinished()
*/
Integration::Scene::EventProcessingFinishedSignalType& EventProcessingFinishedSignal();
/**
- * @copydoc Integration::Scene::TouchSignal()
+ * @copydoc Integration::Scene::TouchedSignal()
*/
- Integration::Scene::TouchSignalType& TouchSignal();
+ Integration::Scene::TouchEventSignalType& TouchedSignal();
/**
* @copydoc Integration::Scene::sWheelEventSignal()
Integration::Scene::WheelEventSignalType& WheelEventSignal();
/**
- * @brief Get ItemsDirtyRects
- *
- * @return the ItemsDirtyRects
+ * @copydoc Integration::Scene::WheelEventGeneratedSignal()
*/
- std::vector<Dali::Internal::SceneGraph::DirtyRect>& GetItemsDirtyRects();
+ Integration::Scene::WheelEventGeneratedSignalType& WheelEventGeneratedSignal();
public:
-
/**
* From RenderTaskDefaults; retrieve the default root actor.
* @return The default root actor.
*/
- virtual Actor& GetDefaultRootActor();
+ Actor& GetDefaultRootActor() override;
/**
* From RenderTaskDefaults; retrieve the default camera actor.
* @return The default camera actor.
*/
- virtual CameraActor& GetDefaultCameraActor();
+ CameraActor& GetDefaultCameraActor() const override;
private:
-
// Constructor
Scene();
* Second-phase constructor.
*
* @param[in] size The size of the set surface
+ * @param[in] orientation The orientation of the set surface for this scene
*/
- void Initialize( Size size );
+ void Initialize(Size size, int32_t orientation);
// Undefined
Scene(const Scene&) = delete;
// Undefined
Scene& operator=(const Scene& rhs) = delete;
+ /**
+ * Informs the scene that the set surface has been resized or rotated.
+ *
+ * @param[in] width The width of rotated surface
+ * @param[in] height The height of rotated surface
+ * @param[in] orientation The orientation of rotated surface
+ */
+ void ChangedSurface(float width, float height, int32_t orientation);
+
private:
Internal::SceneGraph::Scene* mSceneObject;
Vector4 mBackgroundColor;
- // The SurfaceOrientation
- int mSurfaceOrientation;
-
LayerPtr mRootLayer;
// Ordered list of currently on-stage layers
// The list of render-tasks
IntrusivePtr<RenderTaskList> mRenderTaskList;
- bool mDepthTreeDirty:1; ///< True if the depth tree needs recalculating
+ bool mDepthTreeDirty : 1; ///< True if the depth tree needs recalculating
EventProcessor mEventProcessor;
+ // The Surface's orientation
+ int32_t mSurfaceOrientation;
+
// The key event signal
- Integration::Scene::KeyEventSignalType mKeyEventSignal;
- Integration::Scene::KeyEventGeneratedSignalType mKeyEventGeneratedSignal;
+ Integration::Scene::KeyEventSignalType mKeyEventSignal;
+ Integration::Scene::KeyEventGeneratedSignalType mKeyEventGeneratedSignal;
+ Integration::Scene::KeyEventGeneratedSignalType mInterceptKeyEventSignal;
// The event processing finished signal
Integration::Scene::EventProcessingFinishedSignalType mEventProcessingFinishedSignal;
// The touch signal
- Integration::Scene::TouchSignalType mTouchSignal;
+ Integration::Scene::TouchEventSignalType mTouchedSignal;
// The wheel event signal
- Integration::Scene::WheelEventSignalType mWheelEventSignal;
-
- std::vector<Dali::Internal::SceneGraph::DirtyRect> mItemsDirtyRects;
+ Integration::Scene::WheelEventSignalType mWheelEventSignal;
+ Integration::Scene::WheelEventGeneratedSignalType mWheelEventGeneratedSignal;
};
-} // Internal
+} // namespace Internal
// Get impl of handle
inline Internal::Scene& GetImplementation(Dali::Integration::Scene& scene)
{
- DALI_ASSERT_ALWAYS( scene && "Scene handle is empty" );
+ DALI_ASSERT_ALWAYS(scene && "Scene handle is empty");
Dali::RefObject& object = scene.GetBaseObject();
return static_cast<Internal::Scene&>(object);
}
inline const Internal::Scene& GetImplementation(const Dali::Integration::Scene& scene)
{
- DALI_ASSERT_ALWAYS( scene && "Scene handle is empty" );
+ DALI_ASSERT_ALWAYS(scene && "Scene handle is empty");
const Dali::RefObject& object = scene.GetBaseObject();
return static_cast<const Internal::Scene&>(object);
}
-} // Dali
+} // namespace Dali
#endif // DALI_INTERNAL_SCENE_H