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