src/Tizen.NUI/src/public/CameraActor.cs

   1 // Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 // http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14 //
  15 //
  16 // This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
  17 // Some have been manually changed
  18
  19 namespace Tizen.NUI
  20 {
  21
  22     /// <summary>
  23     /// This class will be deprecated.<br>
  24     /// CameraActor controls a camera.<br>
  25     /// Allows the developer to use actor semantics to control a camera.<br>
  26     /// NUI has a concept of a camera to display its virtual 3D world to a 2D screen.<br>
  27     /// There are 2 ways of using the camera in NUI:<br>
  28     /// - For 2D applications, you do not need to care about the camera at all. The default camera is already best suited for 2D applications
  29     /// (configured to have the origin of the coordinate system at the top-left corner of the screen, and unit 1 as 1 pixel of the screen). This is a typical way.<br>
  30     /// - For 3D applications, you can change the view by manipulating the camera.You can translate or rotate the camera in this case.<br>
  31     /// Note that the top-left corner of the screen and unit 1 no longer are (0,0,0) and 1 pixel after manipulating the camera.<br>
  32     /// There are two types of camera actor, FreeLook and LookAtTarget By default, the camera actor will be FreeLook.<br>
  33     /// - A FreeLook camera uses actor's orientation to control where the camera is looking.<br>
  34     /// If no additional rotations are specified, the camera looks in the negative Z direction.<br>
  35     /// - For LookAtTarget, the actor's orientation is ignored, instead the camera looks at TargetPosition in world coordinates.<br>
  36     /// /// </summary>
  37     public class CameraActor : Actor
  38     {
  39         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  40
  41         internal CameraActor(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.CameraActor_SWIGUpcast(cPtr), cMemoryOwn)
  42         {
  43             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  44         }
  45
  46         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CameraActor obj)
  47         {
  48             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  49         }
  50
  51         ~CameraActor()
  52         {
  53             DisposeQueue.Instance.Add(this);
  54         }
  55
  56         /// <summary>
  57         /// To make CameraActor instance be disposed.
  58         /// </summary>
  59         public override void Dispose()
  60         {
  61             if (!Stage.IsInstalled())
  62             {
  63                 DisposeQueue.Instance.Add(this);
  64                 return;
  65             }
  66
  67             lock (this)
  68             {
  69                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
  70                 {
  71                     if (swigCMemOwn)
  72                     {
  73                         swigCMemOwn = false;
  74                         NDalicPINVOKE.delete_CameraActor(swigCPtr);
  75                     }
  76                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  77                 }
  78                 global::System.GC.SuppressFinalize(this);
  79                 base.Dispose();
  80             }
  81         }
  82
  83
  84         internal class Property : global::System.IDisposable
  85         {
  86             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  87             protected bool swigCMemOwn;
  88
  89             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
  90             {
  91                 swigCMemOwn = cMemoryOwn;
  92                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  93             }
  94
  95             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
  96             {
  97                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  98             }
  99
 100             ~Property()
 101             {
 102                 Dispose();
 103             }
 104
 105             public virtual void Dispose()
 106             {
 107                 lock (this)
 108                 {
 109                     if (swigCPtr.Handle != global::System.IntPtr.Zero)
 110                     {
 111                         if (swigCMemOwn)
 112                         {
 113                             swigCMemOwn = false;
 114                             NDalicPINVOKE.delete_CameraActor_Property(swigCPtr);
 115                         }
 116                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 117                     }
 118                     global::System.GC.SuppressFinalize(this);
 119                 }
 120             }
 121
 122             internal Property() : this(NDalicPINVOKE.new_CameraActor_Property(), true)
 123             {
 124                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 125             }
 126
 127             internal static readonly int TYPE = NDalicPINVOKE.CameraActor_Property_TYPE_get();
 128             internal static readonly int PROJECTION_MODE = NDalicPINVOKE.CameraActor_Property_PROJECTION_MODE_get();
 129             internal static readonly int FIELD_OF_VIEW = NDalicPINVOKE.CameraActor_Property_FIELD_OF_VIEW_get();
 130             internal static readonly int ASPECT_RATIO = NDalicPINVOKE.CameraActor_Property_ASPECT_RATIO_get();
 131             internal static readonly int NEAR_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_NEAR_PLANE_DISTANCE_get();
 132             internal static readonly int FAR_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_FAR_PLANE_DISTANCE_get();
 133             internal static readonly int LEFT_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_LEFT_PLANE_DISTANCE_get();
 134             internal static readonly int RIGHT_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_RIGHT_PLANE_DISTANCE_get();
 135             internal static readonly int TOP_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_TOP_PLANE_DISTANCE_get();
 136             internal static readonly int BOTTOM_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_BOTTOM_PLANE_DISTANCE_get();
 137             internal static readonly int TARGET_POSITION = NDalicPINVOKE.CameraActor_Property_TARGET_POSITION_get();
 138             internal static readonly int PROJECTION_MATRIX = NDalicPINVOKE.CameraActor_Property_PROJECTION_MATRIX_get();
 139             internal static readonly int VIEW_MATRIX = NDalicPINVOKE.CameraActor_Property_VIEW_MATRIX_get();
 140             internal static readonly int INVERT_Y_AXIS = NDalicPINVOKE.CameraActor_Property_INVERT_Y_AXIS_get();
 141
 142         }
 143
 144         /// <summary>
 145         /// Creates an initialized CameraActor handle.
 146         /// </summary>
 147         public CameraActor() : this(NDalicPINVOKE.CameraActor_New__SWIG_0(), true)
 148         {
 149             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 150
 151         }
 152
 153         /// <summary>
 154         /// Creates a CameraActor object.<br>
 155         /// Sets the default camera perspective projection for the given canvas size.<br>
 156         /// </summary>
 157         /// <param name="size">The canvas size</param>
 158         public CameraActor(Size2D size) : this(NDalicPINVOKE.CameraActor_New__SWIG_1(Size2D.getCPtr(size)), true)
 159         {
 160             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 161
 162         }
 163
 164         /// <summary>
 165         /// Downcasts a handle to CameraActor handle.<br>
 166         /// If handle points to a CameraActor, the downcast produces valid handle.<br>
 167         /// If not, the returned handle is left uninitialized.<br>
 168         /// </summary>
 169         /// <param name="handle">to An object</param>
 170         /// <returns>Handle to a CameraActor or an uninitialized handle</returns>
 171         public new static CameraActor DownCast(BaseHandle handle)
 172         {
 173             CameraActor ret = new CameraActor(NDalicPINVOKE.CameraActor_DownCast(BaseHandle.getCPtr(handle)), true);
 174             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 175             return ret;
 176         }
 177
 178         internal CameraActor(CameraActor copy) : this(NDalicPINVOKE.new_CameraActor__SWIG_1(CameraActor.getCPtr(copy)), true)
 179         {
 180             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 181         }
 182
 183         internal CameraActor Assign(CameraActor rhs)
 184         {
 185             CameraActor ret = new CameraActor(NDalicPINVOKE.CameraActor_Assign(swigCPtr, CameraActor.getCPtr(rhs)), false);
 186             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 187             return ret;
 188         }
 189
 190         internal void SetType(CameraType type)
 191         {
 192             NDalicPINVOKE.CameraActor_SetType(swigCPtr, (int)type);
 193             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 194         }
 195
 196         internal CameraType GetType()
 197         {
 198             CameraType ret = (CameraType)NDalicPINVOKE.CameraActor_GetType(swigCPtr);
 199             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 200             return ret;
 201         }
 202
 203         internal void SetProjectionMode(ProjectionMode mode)
 204         {
 205             NDalicPINVOKE.CameraActor_SetProjectionMode(swigCPtr, (int)mode);
 206             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 207         }
 208
 209         internal ProjectionMode GetProjectionMode()
 210         {
 211             ProjectionMode ret = (ProjectionMode)NDalicPINVOKE.CameraActor_GetProjectionMode(swigCPtr);
 212             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 213             return ret;
 214         }
 215
 216         internal void SetFieldOfView(float fieldOfView)
 217         {
 218             NDalicPINVOKE.CameraActor_SetFieldOfView(swigCPtr, fieldOfView);
 219             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 220         }
 221
 222         internal float GetFieldOfView()
 223         {
 224             float ret = NDalicPINVOKE.CameraActor_GetFieldOfView(swigCPtr);
 225             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 226             return ret;
 227         }
 228
 229         internal void SetAspectRatio(float aspectRatio)
 230         {
 231             NDalicPINVOKE.CameraActor_SetAspectRatio(swigCPtr, aspectRatio);
 232             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 233         }
 234
 235         internal float GetAspectRatio()
 236         {
 237             float ret = NDalicPINVOKE.CameraActor_GetAspectRatio(swigCPtr);
 238             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 239             return ret;
 240         }
 241
 242         internal void SetNearClippingPlane(float nearClippingPlane)
 243         {
 244             NDalicPINVOKE.CameraActor_SetNearClippingPlane(swigCPtr, nearClippingPlane);
 245             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 246         }
 247
 248         internal float GetNearClippingPlane()
 249         {
 250             float ret = NDalicPINVOKE.CameraActor_GetNearClippingPlane(swigCPtr);
 251             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 252             return ret;
 253         }
 254
 255         internal void SetFarClippingPlane(float farClippingPlane)
 256         {
 257             NDalicPINVOKE.CameraActor_SetFarClippingPlane(swigCPtr, farClippingPlane);
 258             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 259         }
 260
 261         internal float GetFarClippingPlane()
 262         {
 263             float ret = NDalicPINVOKE.CameraActor_GetFarClippingPlane(swigCPtr);
 264             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 265             return ret;
 266         }
 267
 268         internal void SetTargetPosition(Vector3 targetPosition)
 269         {
 270             NDalicPINVOKE.CameraActor_SetTargetPosition(swigCPtr, Vector3.getCPtr(targetPosition));
 271             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 272         }
 273
 274         internal Vector3 GetTargetPosition()
 275         {
 276             Vector3 ret = new Vector3(NDalicPINVOKE.CameraActor_GetTargetPosition(swigCPtr), true);
 277             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 278             return ret;
 279         }
 280
 281         internal void SetInvertYAxis(bool invertYAxis)
 282         {
 283             NDalicPINVOKE.CameraActor_SetInvertYAxis(swigCPtr, invertYAxis);
 284             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 285         }
 286
 287         internal bool GetInvertYAxis()
 288         {
 289             bool ret = NDalicPINVOKE.CameraActor_GetInvertYAxis(swigCPtr);
 290             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 291             return ret;
 292         }
 293
 294         internal void SetPerspectiveProjection(Vector2 size)
 295         {
 296             NDalicPINVOKE.CameraActor_SetPerspectiveProjection(swigCPtr, Vector2.getCPtr(size));
 297             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 298         }
 299
 300         internal void SetOrthographicProjection(Vector2 size)
 301         {
 302             NDalicPINVOKE.CameraActor_SetOrthographicProjection__SWIG_0(swigCPtr, Vector2.getCPtr(size));
 303             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 304         }
 305
 306         internal void SetOrthographicProjection(float left, float right, float top, float bottom, float near, float far)
 307         {
 308             NDalicPINVOKE.CameraActor_SetOrthographicProjection__SWIG_1(swigCPtr, left, right, top, bottom, near, far);
 309             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 310         }
 311
 312         /// <summary>
 313         /// Gets/Sets the camera type. The default type is FreeLook
 314         /// </summary>
 315         public CameraType Type
 316         {
 317             get
 318             {
 319                 string temp;
 320                 if (GetProperty(CameraActor.Property.TYPE).Get(out temp) == false)
 321                 {
 322                     //Tizen.Log.Error("NUI", "CameraType get error!");
 323                 }
 324                 switch (temp)
 325                 {
 326                     case "LOOK_AT_TARGET":
 327                         return CameraType.LookAtTarget;
 328                     case "FREE_LOOK":
 329                         return CameraType.FreeLook;
 330                     default:
 331                         return CameraType.FreeLook;
 332                 }
 333             }
 334             set
 335             {
 336                 string valueToString = "";
 337                 switch (value)
 338                 {
 339                     case CameraType.LookAtTarget:
 340                     {
 341                         valueToString = "LOOK_AT_TARGET";
 342                         break;
 343                     }
 344                     case CameraType.FreeLook:
 345                     {
 346                         valueToString = "FREE_LOOK";
 347                         break;
 348                     }
 349                     default:
 350                     {
 351                         valueToString = "FREE_LOOK";
 352                         break;
 353                     }
 354                 }
 355                 SetProperty(CameraActor.Property.TYPE, new Tizen.NUI.PropertyValue(valueToString));
 356             }
 357         }
 358
 359         /// <summary>
 360         /// Gets/Sets the projection mode.
 361         /// </summary>
 362         public ProjectionMode ProjectionMode
 363         {
 364             get
 365             {
 366                 string temp;
 367                 if (GetProperty(CameraActor.Property.PROJECTION_MODE).Get(out temp) == false)
 368                 {
 369                     //Tizen.Log.Error("NUI", "ProjectionMode get error!");
 370                 }
 371                 switch(temp)
 372                 {
 373                     case "PERSPECTIVE_PROJECTION":
 374                         return ProjectionMode.PerspectiveProjection;
 375                     case "ORTHOGRAPHIC_PROJECTION":
 376                         return ProjectionMode.OrthographicProjection;
 377                     default:
 378                         return ProjectionMode.PerspectiveProjection;
 379                 }
 380             }
 381             set
 382             {
 383                 string valueToString = "";
 384                 switch (value)
 385                 {
 386                     case ProjectionMode.PerspectiveProjection:
 387                     {
 388                         valueToString = "PERSPECTIVE_PROJECTION";
 389                         break;
 390                     }
 391                     case ProjectionMode.OrthographicProjection:
 392                     {
 393                         valueToString = "ORTHOGRAPHIC_PROJECTION";
 394                         break;
 395                     }
 396                     default:
 397                     {
 398                         valueToString = "PERSPECTIVE_PROJECTION";
 399                         break;
 400                     }
 401                 }
 402                 SetProperty(CameraActor.Property.PROJECTION_MODE, new Tizen.NUI.PropertyValue(valueToString));
 403             }
 404         }
 405
 406         /// <summary>
 407         /// Gets/Sets the field of view.
 408         /// </summary>
 409         public float FieldOfView
 410         {
 411             get
 412             {
 413                 float temp = 0.0f;
 414                 GetProperty(CameraActor.Property.FIELD_OF_VIEW).Get(ref temp);
 415                 return temp;
 416             }
 417             set
 418             {
 419                 SetProperty(CameraActor.Property.FIELD_OF_VIEW, new Tizen.NUI.PropertyValue(value));
 420             }
 421         }
 422
 423         /// <summary>
 424         /// Gets/Sets the aspect ratio of the camera.
 425         /// </summary>
 426         public float AspectRatio
 427         {
 428             get
 429             {
 430                 float temp = 0.0f;
 431                 GetProperty(CameraActor.Property.ASPECT_RATIO).Get(ref temp);
 432                 return temp;
 433             }
 434             set
 435             {
 436                 SetProperty(CameraActor.Property.ASPECT_RATIO, new Tizen.NUI.PropertyValue(value));
 437             }
 438         }
 439
 440         /// <summary>
 441         /// Gets/Sets near plane distance.
 442         /// </summary>
 443         public float NearPlaneDistance
 444         {
 445             get
 446             {
 447                 float temp = 0.0f;
 448                 GetProperty(CameraActor.Property.NEAR_PLANE_DISTANCE).Get(ref temp);
 449                 return temp;
 450             }
 451             set
 452             {
 453                 SetProperty(CameraActor.Property.NEAR_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
 454             }
 455         }
 456
 457         /// <summary>
 458         /// Gets/Sets far plane distance.
 459         /// </summary>
 460         public float FarPlaneDistance
 461         {
 462             get
 463             {
 464                 float temp = 0.0f;
 465                 GetProperty(CameraActor.Property.FAR_PLANE_DISTANCE).Get(ref temp);
 466                 return temp;
 467             }
 468             set
 469             {
 470                 SetProperty(CameraActor.Property.FAR_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
 471             }
 472         }
 473
 474         /// <summary>
 475         /// Gets/Sets left plane distance.
 476         /// </summary>
 477         public float LeftPlaneDistance
 478         {
 479             get
 480             {
 481                 float temp = 0.0f;
 482                 GetProperty(CameraActor.Property.LEFT_PLANE_DISTANCE).Get(ref temp);
 483                 return temp;
 484             }
 485             set
 486             {
 487                 SetProperty(CameraActor.Property.LEFT_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
 488             }
 489         }
 490
 491         /// <summary>
 492         /// Gets/Sets right plane distance.
 493         /// </summary>
 494         public float RightPlaneDistance
 495         {
 496             get
 497             {
 498                 float temp = 0.0f;
 499                 GetProperty(CameraActor.Property.RIGHT_PLANE_DISTANCE).Get(ref temp);
 500                 return temp;
 501             }
 502             set
 503             {
 504                 SetProperty(CameraActor.Property.RIGHT_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
 505             }
 506         }
 507
 508         /// <summary>
 509         /// Gets/Sets top plane distance.
 510         /// </summary>
 511         public float TopPlaneDistance
 512         {
 513             get
 514             {
 515                 float temp = 0.0f;
 516                 GetProperty(CameraActor.Property.TOP_PLANE_DISTANCE).Get(ref temp);
 517                 return temp;
 518             }
 519             set
 520             {
 521                 SetProperty(CameraActor.Property.TOP_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
 522             }
 523         }
 524
 525         /// <summary>
 526         /// Gets/Sets bottom plane distance.
 527         /// </summary>
 528         public float BottomPlaneDistance
 529         {
 530             get
 531             {
 532                 float temp = 0.0f;
 533                 GetProperty(CameraActor.Property.BOTTOM_PLANE_DISTANCE).Get(ref temp);
 534                 return temp;
 535             }
 536             set
 537             {
 538                 SetProperty(CameraActor.Property.BOTTOM_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
 539             }
 540         }
 541
 542         /// <summary>
 543         /// Gets/Sets the target position of the camera.
 544         /// </summary>
 545         public Position TargetPosition
 546         {
 547             get
 548             {
 549                 Position temp = new Position(0.0f, 0.0f, 0.0f);
 550                 GetProperty(CameraActor.Property.TARGET_POSITION).Get(temp);
 551                 return temp;
 552             }
 553             set
 554             {
 555                 SetProperty(CameraActor.Property.TARGET_POSITION, new Tizen.NUI.PropertyValue(value));
 556             }
 557         }
 558         internal Matrix ProjectionMatrix
 559         {
 560             get
 561             {
 562                 Matrix temp = new Matrix();
 563                 GetProperty(CameraActor.Property.PROJECTION_MATRIX).Get(temp);
 564                 return temp;
 565             }
 566         }
 567
 568         internal Matrix ViewMatrix
 569         {
 570             get
 571             {
 572                 Matrix temp = new Matrix();
 573                 GetProperty(CameraActor.Property.VIEW_MATRIX).Get(temp);
 574                 return temp;
 575             }
 576         }
 577
 578         /// <summary>
 579         /// Requests for an inversion on the Y axis on the projection calculation.
 580         /// </summary>
 581         public bool InvertYAxis
 582         {
 583             get
 584             {
 585                 bool temp = false;
 586                 GetProperty(CameraActor.Property.INVERT_Y_AXIS).Get(ref temp);
 587                 return temp;
 588             }
 589             set
 590             {
 591                 SetProperty(CameraActor.Property.INVERT_Y_AXIS, new Tizen.NUI.PropertyValue(value));
 592             }
 593         }
 594
 595     }
 596
 597     /// <summary>
 598     /// Enumeration for type determination of how camera operates.<br>
 599     /// FreeLook : Camera orientation is taken from CameraActor.<br>
 600     /// LookAtTarget : Camera is oriented to always look at a target.<br>
 601     /// </summary>
 602     public enum CameraType
 603     {
 604         FreeLook,
 605         LookAtTarget
 606     }
 607
 608     /// <summary>
 609     /// Enumeration for projection modes.<br>
 610     /// PerspectiveProjection : Distance causes foreshortening; objects further from the camera appear smaller.<br>
 611     /// OrthographicProjection : Relative distance from the camera does not affect the size of objects.<br>
 612     /// </summary>
 613     public enum ProjectionMode
 614     {
 615         PerspectiveProjection,
 616         OrthographicProjection
 617     }
 618
 619 }