[Tizen] Add screen and client rotation itself function
[platform/core/uifw/dali-core.git] / dali / internal / event / actors / camera-actor-impl.h
1 #ifndef DALI_INTERNAL_CAMERA_ACTOR_H
2 #define DALI_INTERNAL_CAMERA_ACTOR_H
3
4 /*
5  * Copyright (c) 2019 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 INCLUES
22 #include <dali/public-api/actors/camera-actor.h>
23 #include <dali/internal/event/actors/actor-impl.h>
24 #include <dali/internal/event/actors/actor-declarations.h>
25
26 namespace Dali
27 {
28
29 namespace Internal
30 {
31
32 namespace SceneGraph
33 {
34 class Camera;
35 }
36
37 /**
38  * An actor with Camera.
39  */
40 class CameraActor : public Actor
41 {
42 public:
43
44   /**
45    * Create an initialised camera actor.
46    *
47    * Sets the default camera perspective projection for the given canvas size. @see SetPerspectiveProjection().
48    *
49    * @param[in] size The canvas size.
50    *
51    * @return A smart-pointer to a newly allocated camera actor.
52    */
53   static CameraActorPtr New( const Size& size );
54
55   /**
56    * @copydoc Dali::CameraActor::SetTargetPosition
57    */
58   void SetTarget( const Vector3& targetPosition );
59
60   /**
61    * @copydoc Dali::CameraActor::GetTargetPosition
62    */
63   Vector3 GetTarget() const;
64
65   /**
66    * @copydoc Dali::CameraActor::SetType
67    */
68   void SetType( Dali::Camera::Type type );
69
70   /**
71    * @copydoc Dali::CameraActor::GetType
72    */
73   Dali::Camera::Type GetType() const;
74
75   /**
76    * @copydoc Dali::CameraActor::SetProjectionMode
77    */
78   void SetProjectionMode( Dali::Camera::ProjectionMode mode );
79
80   /**
81    * @copydoc Dali::CameraActor::GetProjectionMode
82    */
83   Dali::Camera::ProjectionMode GetProjectionMode() const;
84
85   /**
86    * @copydoc Dali::CameraActor::SetFieldOfView
87    */
88   void SetFieldOfView( float fieldOfView );
89
90   /**
91    * @copydoc Dali::CameraActor::GetFieldOfView
92    */
93   float GetFieldOfView() const;
94
95   /**
96    * @copydoc Dali::CameraActor::SetAspectRatio
97    */
98   void SetAspectRatio( float aspectRatio );
99
100   /**
101    * @copydoc Dali::CameraActor::GetAspectRatio
102    */
103   float GetAspectRatio() const;
104
105   /**
106    * @copydoc Dali::CameraActor::SetNearClippingPlane
107    */
108   void SetNearClippingPlane( float nearClippingPlane );
109
110   /**
111    * @copydoc Dali::CameraActor::GetNearClippingPlane
112    */
113   float GetNearClippingPlane() const;
114
115   /**
116    * @copydoc Dali::CameraActor::SetFarClippingPlane
117    */
118   void SetFarClippingPlane( float farClippingPlane );
119
120   /**
121    * @copydoc Dali::CameraActor::GetFarClippingPlane
122    */
123   float GetFarClippingPlane() const;
124
125   /**
126    * @param leftClippingPlane to use
127    */
128   void SetLeftClippingPlane( float leftClippingPlane );
129
130   /**
131    * @param rightClippingPlane to use
132    */
133   void SetRightClippingPlane( float rightClippingPlane );
134
135   /**
136    * @param topClippingPlane to use
137    */
138   void SetTopClippingPlane( float topClippingPlane );
139
140   /**
141    * @param bottomClippingPlane to use
142    */
143   void SetBottomClippingPlane( float bottomClippingPlane );
144
145   /**
146    * @copydoc Dali::CameraActor::SetInvertYAxis
147    */
148   void SetInvertYAxis( bool invertYAxis );
149
150   /**
151    * @copydoc Dali::CameraActor::GetCurrentInvertYAxis
152    */
153   bool GetInvertYAxis() const;
154
155   /**
156    * @copydoc Dali::CameraActor::SetPerspectiveProjection()
157    */
158   void SetPerspectiveProjection( const Size& size );
159
160   /**
161    * @copydoc Dali::CameraActor::SetOrthographicProjection(const Vector2& size);
162    */
163   void SetOrthographicProjection( const Vector2& size );
164
165   /**
166    * @copydoc Dali::CameraActor::SetOrthographicProjection(float left, float right, float top, float bottom, float near, float far);
167    */
168   void SetOrthographicProjection( float left, float right, float top, float bottom, float near, float far );
169
170   /**
171    * Build a picking ray with this camera and given screen coordinates
172    * @param [in] screenCoordinates the ray passed through
173    * @param [in] viewport to use
174    * @param [out] rayOrigin for the picking ray
175    * @param [out] rayDirection for the picking ray
176    * @return true if the building was successful, false if its not possible (camera is not valid for hit testing)
177    */
178   bool BuildPickingRay( const Vector2& screenCoordinates, const Viewport& viewport, Vector4& rayOrigin, Vector4& rayDirection );
179
180   /**
181    * Retrieve the view-matrix; This will only be valid when the actor is on-stage.
182    * @return The view-matrix.
183    */
184   const Matrix& GetViewMatrix() const;
185
186   /**
187    * Retrieve the projection-matrix; This will only be valid when the actor is on-stage.
188    * @return The projection-matrix.
189    */
190   const Matrix& GetProjectionMatrix() const;
191
192   /**
193    * Return the scene graph camera (for RenderTask)
194    * @return The scene graph camera.
195    */
196   const SceneGraph::Camera* GetCamera() const;
197
198   /**
199    * Rotate the projection.
200    * It is used in case that the target buffer direction is different from the window direction.
201    * @param [in] rotationAngle The rotation angle
202    */
203   void RotateProjection( int rotationAngle );
204
205 public: // properties
206
207   /**
208    * copydoc Dali::Internal::Object::SetDefaultProperty()
209    */
210   virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue );
211
212   /**
213    * copydoc Dali::Internal::Object::GetDefaultProperty()
214    */
215   virtual Property::Value GetDefaultProperty( Property::Index index ) const;
216
217   /**
218    * copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
219    */
220   virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
221
222   /**
223    * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
224    */
225   virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
226
227 private:
228
229   /**
230    * Constructor; see also CameraActor::New()
231    * @param node the scene graph node
232    */
233   CameraActor( const SceneGraph::Node& node );
234
235   /**
236    * A reference counted object may only be deleted by calling Unreference()
237    */
238   virtual ~CameraActor();
239
240
241   /**
242    * @copydoc Dali::Internal::Actor::OnInitialize()
243    */
244   virtual void OnInitialize();
245
246
247 private: // Data
248
249   const SceneGraph::Camera* mSceneObject; ///< Not owned
250
251   Vector3            mTarget;
252   Dali::Camera::Type mType;
253   Dali::Camera::ProjectionMode mProjectionMode;
254   float              mFieldOfView;
255   float              mAspectRatio;
256   float              mNearClippingPlane;
257   float              mFarClippingPlane;
258   float              mLeftClippingPlane;
259   float              mRightClippingPlane;
260   float              mTopClippingPlane;
261   float              mBottomClippingPlane;
262   bool               mInvertYAxis;
263
264 };
265
266 } // namespace Internal
267
268 // Helpers for public-api forwarding methods
269
270 inline Internal::CameraActor& GetImplementation(Dali::CameraActor& camera)
271 {
272   DALI_ASSERT_ALWAYS(camera && "Camera handle is empty");
273
274   BaseObject& handle = camera.GetBaseObject();
275
276   return static_cast<Internal::CameraActor&>(handle);
277 }
278
279 inline const Internal::CameraActor& GetImplementation(const Dali::CameraActor& camera)
280 {
281   DALI_ASSERT_ALWAYS(camera && "Camera handle is empty");
282
283   const BaseObject& handle = camera.GetBaseObject();
284
285   return static_cast<const Internal::CameraActor&>(handle);
286 }
287
288 } // namespace Dali
289
290 #endif // DALI_INTERNAL_CAMERA_ACTOR_H