src/Tizen.NUI.Scene3D/src/public/Controls/Camera.cs

   1 /*
   2  * Copyright(c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 using System;
  18 using System.ComponentModel;
  19 using Tizen.NUI.BaseComponents;
  20
  21 namespace Tizen.NUI.Scene3D
  22 {
  23     /// <summary>
  24     /// Camera class controls a camera in 3D space.
  25     ///
  26     /// Camera can be added on the SceneView and displays SceneView's virtual 3D world to the screen.
  27     /// Camera can be translated and rotated in the space.
  28     /// </summary>
  29     /// <remarks>
  30     /// Transform inheritance cannot be guaranteed when adding children to a camera.
  31     /// </remarks>
  32     /// <since_tizen> 10 </since_tizen>
  33     public partial class Camera : View
  34     {
  35         internal Camera(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
  36         {
  37         }
  38
  39         /// <summary>
  40         /// Creates an uninitialized Camera.
  41         /// </summary>
  42         /// <since_tizen> 10 </since_tizen>
  43         public Camera() : this(Interop.Camera.New(), true)
  44         {
  45             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  46         }
  47
  48         /// <summary>
  49         /// Copy constructor.
  50         /// </summary>
  51         /// <param name="camera">The Camera object to be copied.</param>
  52         /// <since_tizen> 10 </since_tizen>
  53         public Camera(Camera camera) : this(Interop.Camera.NewCamera(Camera.getCPtr(camera)), true)
  54         {
  55             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  56         }
  57
  58         /// <summary>
  59         /// Assignment.
  60         /// </summary>
  61         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
  62         [EditorBrowsable(EditorBrowsableState.Never)]
  63         public Camera Assign(Camera rhs)
  64         {
  65             Camera ret = new Camera(Interop.Camera.Assign(SwigCPtr, Camera.getCPtr(rhs)), false);
  66             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  67             return ret;
  68         }
  69
  70         /// <summary>
  71         /// Creates a CameraActor object.
  72         /// Sets the default camera perspective projection for the given canvas size..
  73         /// </summary>
  74         internal Camera(Vector2 size) : this(Interop.Camera.New(Vector2.getCPtr(size)), true)
  75         {
  76             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  77         }
  78
  79         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
  80         [EditorBrowsable(EditorBrowsableState.Never)]
  81         internal static Camera DownCast(BaseHandle handle)
  82         {
  83             if (handle == null)
  84             {
  85                 throw new global::System.ArgumentNullException(nameof(handle));
  86             }
  87             Camera ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as Camera;
  88             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  89             return ret;
  90         }
  91
  92         /// <summary>
  93         /// Enumeration for the projectionMode.
  94         /// ProjectionMode defines how the camera shows 3D objects or scene on a 2D plane with projection.
  95         /// </summary>
  96         /// <since_tizen> 10 </since_tizen>
  97         public enum ProjectionModeType
  98         {
  99             /// <summary>
 100             /// Distance causes foreshortening; objects further from the camera appear smaller.
 101             /// </summary>
 102             Perspective,
 103             /// <summary>
 104             /// Relative distance from the camera does not affect the size of objects.
 105             /// </summary>
 106             Orthographic
 107         }
 108
 109         /// <summary>
 110         /// Enumeration for the projectionDirection.
 111         /// </summary>
 112         /// This will be released at Tizen.NET API Level 10, so currently this would be used as inhouse API.
 113         [EditorBrowsable(EditorBrowsableState.Never)]
 114         public enum ProjectionDirectionType
 115         {
 116             /// <summary>
 117             /// Distance causes foreshortening; objects further from the camera appear smaller.
 118             /// </summary>
 119             Vertical,
 120             /// <summary>
 121             /// Relative distance from the camera does not affect the size of objects.
 122             /// </summary>
 123             Horizontal
 124         }
 125
 126         /// <summary>
 127         /// Sets/Gets the projection mode.
 128         /// The default is Perspective
 129         /// </summary>
 130         /// <since_tizen> 10 </since_tizen>
 131         public ProjectionModeType ProjectionMode
 132         {
 133             get
 134             {
 135                 return (ProjectionModeType)GetValue(ProjectionProperty);
 136             }
 137             set
 138             {
 139                 SetValue(ProjectionProperty, value);
 140                 NotifyPropertyChanged();
 141             }
 142         }
 143
 144         /// <summary>
 145         /// <para>
 146         /// Sets/Gets the projection direction.
 147         /// Projection direction determine basic direction of projection relative properties.
 148         /// It will be used when we need to calculate some values relative with aspect ratio.
 149         /// <see cref="FieldOfView"/>, and <see cref="OrthographicSize"/>
 150         /// </para>
 151         /// <para>
 152         /// For example, if aspect ratio is 4:3 and set fieldOfView as 60 degree.
 153         /// If ProjectionDirectionType.Vertical, basic direction is vertical. so, FoV of horizontal direction become ~75.2 degree
 154         /// If ProjectionDirectionType.Horizontal, basic direction is horizontal. so, FoV of vertical direction become ~46.8 degree
 155         /// </para>
 156         /// <note>
 157         /// This property doesn't change <see cref="FieldOfView"/> and <see cref="OrthographicSize"/> value automatically.
 158         /// So result scene might be changed.
 159         /// </note>
 160         /// <para>The default is Vertical.</para>
 161         /// </summary>
 162         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 163         [EditorBrowsable(EditorBrowsableState.Never)]
 164         public ProjectionDirectionType ProjectionDirection
 165         {
 166             get
 167             {
 168                 return (ProjectionDirectionType)GetValue(ProjectionDirectionProperty);
 169             }
 170             set
 171             {
 172                 SetValue(ProjectionDirectionProperty, value);
 173                 NotifyPropertyChanged();
 174             }
 175         }
 176
 177         /// <summary>
 178         /// Sets/Gets the field of view in Radians.
 179         /// FieldOfView depends on <see cref="ProjectionDirection"/> value.
 180         /// The default field of view is 45 degrees.
 181         /// </summary>
 182         /// <since_tizen> 10 </since_tizen>
 183         public Radian FieldOfView
 184         {
 185             get
 186             {
 187                 return new Radian((float)GetValue(FieldOfViewProperty));
 188             }
 189             set
 190             {
 191                 SetValue(FieldOfViewProperty, value?.ConvertToFloat() ?? 0.0f);
 192                 NotifyPropertyChanged();
 193             }
 194         }
 195
 196         /// <summary>
 197         /// Sets/Gets Orthographic Size of this camera.
 198         /// OrthographicSize depends on <see cref="ProjectionDirection"/> value.
 199         /// If ProjectoinDirection is Vertical, OrthographicSize is height/2 of viewing cube of Orthographic projection.
 200         /// If ProjectoinDirection is Horizontal, OrthographicSize is width/2 of viewing cube of Orthographic projection.
 201         /// Remained Width or Height of viewing cube is internally computed by using aspect ratio of Viewport.
 202         /// </summary>
 203         /// <since_tizen> 10 </since_tizen>
 204         public float OrthographicSize
 205         {
 206             get
 207             {
 208                 return InternalOrthographicSize;
 209             }
 210             set
 211             {
 212                 SetValue(OrthographicSizeProperty, value);
 213                 NotifyPropertyChanged();
 214             }
 215         }
 216
 217         /// <summary>
 218         /// Gets the aspect ratio of the camera.
 219         /// </summary>
 220         /// <since_tizen> 10 </since_tizen>
 221         public float AspectRatio
 222         {
 223             get
 224             {
 225                 return (float)GetValue(AspectRatioProperty);
 226             }
 227         }
 228
 229         /// <summary>
 230         /// Sets/Gets the near clipping plane distance.
 231         /// </summary>
 232         /// <since_tizen> 10 </since_tizen>
 233         public float NearPlaneDistance
 234         {
 235             get
 236             {
 237                 return (float)GetValue(NearPlaneDistanceProperty);
 238             }
 239             set
 240             {
 241                 SetValue(NearPlaneDistanceProperty, value);
 242                 NotifyPropertyChanged();
 243             }
 244         }
 245
 246         /// <summary>
 247         /// Sets/Gets the far clipping plane distance.
 248         /// </summary>
 249         /// <since_tizen> 10 </since_tizen>
 250         public float FarPlaneDistance
 251         {
 252             get
 253             {
 254                 return (float)GetValue(FarPlaneDistanceProperty);
 255             }
 256             set
 257             {
 258                 SetValue(FarPlaneDistanceProperty, value);
 259                 NotifyPropertyChanged();
 260             }
 261         }
 262
 263         /// <summary>
 264         /// Gets the left clipping plane distance.
 265         /// </summary>
 266         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 267         [EditorBrowsable(EditorBrowsableState.Never)]
 268         public float LeftPlaneDistance
 269         {
 270             get
 271             {
 272                 return (float)GetValue(LeftPlaneDistanceProperty);
 273             }
 274         }
 275
 276         /// <summary>
 277         /// Gets the right clipping plane distance.
 278         /// </summary>
 279         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 280         [EditorBrowsable(EditorBrowsableState.Never)]
 281         public float RightPlaneDistance
 282         {
 283             get
 284             {
 285                 return (float)GetValue(RightPlaneDistanceProperty);
 286             }
 287         }
 288
 289         /// <summary>
 290         /// Gets the top clipping plane distance.
 291         /// </summary>
 292         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 293         [EditorBrowsable(EditorBrowsableState.Never)]
 294         public float TopPlaneDistance
 295         {
 296             get
 297             {
 298                 return (float)GetValue(TopPlaneDistanceProperty);
 299             }
 300         }
 301
 302         /// <summary>
 303         /// Gets the bottom clipping plane distance.
 304         /// </summary>
 305         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 306         [EditorBrowsable(EditorBrowsableState.Never)]
 307         public float BottomPlaneDistance
 308         {
 309             get
 310             {
 311                 return (float)GetValue(BottomPlaneDistanceProperty);
 312             }
 313         }
 314
 315         /// <summary>
 316         /// Requests for an inversion on the Y axis on the projection calculation.
 317         /// or gets whether the Y axis is inverted.
 318         /// </summary>
 319         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 320         [EditorBrowsable(EditorBrowsableState.Never)]
 321         public bool InvertYAxis
 322         {
 323             get
 324             {
 325                 return (bool)GetValue(InvertYAxisProperty);
 326             }
 327             set
 328             {
 329                 SetValue(InvertYAxisProperty, value);
 330                 NotifyPropertyChanged();
 331             }
 332         }
 333
 334         /// <summary>
 335         /// Gets ProjectionMatrix of this Camera
 336         /// TODO : Open Matrix
 337         /// </summary>
 338         internal Matrix ProjectionMatrix
 339         {
 340             get
 341             {
 342                 Matrix returnValue = new Matrix();
 343                 PropertyValue projectionMatrix = GetProperty(Interop.Camera.ProjectionMatrixGet());
 344                 projectionMatrix?.Get(returnValue);
 345                 projectionMatrix?.Dispose();
 346                 return returnValue;
 347             }
 348         }
 349
 350         /// <summary>
 351         /// Gets ViewMatrix of this Camera
 352         /// TODO : Open Matrix
 353         /// </summary>
 354         internal Matrix ViewMatrix
 355         {
 356             get
 357             {
 358                 Matrix returnValue = new Matrix();
 359                 PropertyValue viewMatrix = GetProperty(Interop.Camera.ViewMatrixGet());
 360                 viewMatrix.Get(returnValue);
 361                 viewMatrix.Dispose();
 362                 return returnValue;
 363             }
 364         }
 365
 366         private ProjectionModeType InternalProjectionMode
 367         {
 368             get
 369             {
 370                 int returnValue = (int)ProjectionModeType.Perspective;
 371                 PropertyValue projectionMode = GetProperty(Interop.Camera.ProjectionModeGet());
 372                 projectionMode?.Get(out returnValue);
 373                 projectionMode?.Dispose();
 374                 return (ProjectionModeType)returnValue;
 375             }
 376             set
 377             {
 378                 PropertyValue setValue = new Tizen.NUI.PropertyValue((int)value);
 379                 SetProperty(Interop.Camera.ProjectionModeGet(), setValue);
 380                 setValue.Dispose();
 381             }
 382         }
 383
 384         private ProjectionDirectionType InternalProjectionDirection
 385         {
 386             get
 387             {
 388                 int returnValue = (int)ProjectionDirectionType.Vertical;
 389                 PropertyValue projectionDirection = GetProperty(Interop.Camera.ProjectionDirectionGet());
 390                 projectionDirection?.Get(out returnValue);
 391                 projectionDirection?.Dispose();
 392                 return (ProjectionDirectionType)returnValue;
 393             }
 394             set
 395             {
 396                 PropertyValue setValue = new Tizen.NUI.PropertyValue((int)value);
 397                 SetProperty(Interop.Camera.ProjectionDirectionGet(), setValue);
 398                 setValue.Dispose();
 399             }
 400         }
 401
 402         private float InternalFieldOfView
 403         {
 404             get
 405             {
 406                 float returnValue = 0.0f;
 407                 PropertyValue fieldView = GetProperty(Interop.Camera.FieldOfViewGet());
 408                 fieldView?.Get(out returnValue);
 409                 fieldView?.Dispose();
 410                 return returnValue;
 411             }
 412             set
 413             {
 414                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 415                 SetProperty(Interop.Camera.FieldOfViewGet(), setValue);
 416                 setValue.Dispose();
 417             }
 418         }
 419
 420         private float InternalOrthographicSize
 421         {
 422             get
 423             {
 424                 float returnValue = 0.0f;
 425                 PropertyValue orthographicSize = GetProperty(Interop.Camera.OrthographicSizeGet());
 426                 orthographicSize?.Get(out returnValue);
 427                 orthographicSize?.Dispose();
 428                 return returnValue;
 429             }
 430             set
 431             {
 432                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 433                 SetProperty(Interop.Camera.OrthographicSizeGet(), setValue);
 434                 setValue.Dispose();
 435             }
 436         }
 437
 438         private float InternalAspectRatio
 439         {
 440             get
 441             {
 442                 float returnValue = 0.0f;
 443                 PropertyValue aspectRatio = GetProperty(Interop.Camera.AspectRatioGet());
 444                 aspectRatio?.Get(out returnValue);
 445                 aspectRatio?.Dispose();
 446                 return returnValue;
 447             }
 448             set
 449             {
 450                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 451                 SetProperty(Interop.Camera.AspectRatioGet(), setValue);
 452                 setValue.Dispose();
 453             }
 454         }
 455
 456         private float InternalNearPlaneDistance
 457         {
 458             get
 459             {
 460                 float returnValue = 0.0f;
 461                 PropertyValue nearPlaneDistance = GetProperty(Interop.Camera.NearPlaneDistanceGet());
 462                 nearPlaneDistance?.Get(out returnValue);
 463                 nearPlaneDistance?.Dispose();
 464                 return returnValue;
 465             }
 466             set
 467             {
 468                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 469                 SetProperty(Interop.Camera.NearPlaneDistanceGet(), setValue);
 470                 setValue.Dispose();
 471             }
 472         }
 473
 474         private float InternalFarPlaneDistance
 475         {
 476             get
 477             {
 478                 float returnValue = 0.0f;
 479                 PropertyValue farPlaneDistance = GetProperty(Interop.Camera.FarPlaneDistanceGet());
 480                 farPlaneDistance?.Get(out returnValue);
 481                 farPlaneDistance?.Dispose();
 482                 return returnValue;
 483             }
 484             set
 485             {
 486                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 487                 SetProperty(Interop.Camera.FarPlaneDistanceGet(), setValue);
 488                 setValue.Dispose();
 489             }
 490         }
 491
 492         private float InternalLeftPlaneDistance
 493         {
 494             get
 495             {
 496                 float returnValue = 0.0f;
 497                 PropertyValue leftPlaneDistance = GetProperty(Interop.Camera.LeftPlaneDistanceGet());
 498                 leftPlaneDistance?.Get(out returnValue);
 499                 leftPlaneDistance?.Dispose();
 500                 return returnValue;
 501             }
 502             set
 503             {
 504                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 505                 SetProperty(Interop.Camera.LeftPlaneDistanceGet(), setValue);
 506                 setValue.Dispose();
 507             }
 508         }
 509
 510         private float InternalRightPlaneDistance
 511         {
 512             get
 513             {
 514                 float returnValue = 0.0f;
 515                 PropertyValue rightPlaneDistance = GetProperty(Interop.Camera.RightPlaneDistanceGet());
 516                 rightPlaneDistance?.Get(out returnValue);
 517                 rightPlaneDistance?.Dispose();
 518                 return returnValue;
 519             }
 520             set
 521             {
 522                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 523                 SetProperty(Interop.Camera.RightPlaneDistanceGet(), setValue);
 524                 setValue.Dispose();
 525             }
 526         }
 527
 528         private float InternalTopPlaneDistance
 529         {
 530             get
 531             {
 532                 float returnValue = 0.0f;
 533                 PropertyValue topPlaneDistance = GetProperty(Interop.Camera.TopPlaneDistanceGet());
 534                 topPlaneDistance?.Get(out returnValue);
 535                 topPlaneDistance?.Dispose();
 536                 return returnValue;
 537             }
 538             set
 539             {
 540                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 541                 SetProperty(Interop.Camera.TopPlaneDistanceGet(), setValue);
 542                 setValue.Dispose();
 543             }
 544         }
 545
 546         private float InternalBottomPlaneDistance
 547         {
 548             get
 549             {
 550                 float returnValue = 0.0f;
 551                 PropertyValue bottomPlaneDistance = GetProperty(Interop.Camera.BottomPlaneDistanceGet());
 552                 bottomPlaneDistance?.Get(out returnValue);
 553                 bottomPlaneDistance?.Dispose();
 554                 return returnValue;
 555             }
 556             set
 557             {
 558                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 559                 SetProperty(Interop.Camera.BottomPlaneDistanceGet(), setValue);
 560                 setValue.Dispose();
 561             }
 562         }
 563
 564         private bool InternalInvertYAxis
 565         {
 566             get
 567             {
 568                 bool returnValue = false;
 569                 PropertyValue invertYAxis = GetProperty(Interop.Camera.InvertYAxisGet());
 570                 invertYAxis?.Get(out returnValue);
 571                 invertYAxis?.Dispose();
 572                 return returnValue;
 573             }
 574             set
 575             {
 576                 PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
 577                 SetProperty(Interop.Camera.InvertYAxisGet(), setValue);
 578                 setValue.Dispose();
 579             }
 580         }
 581
 582         internal void SetProjection(ProjectionModeType mode)
 583         {
 584             Interop.Camera.SetProjectionMode(SwigCPtr, (int)mode);
 585             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 586         }
 587
 588         internal ProjectionModeType GetProjection()
 589         {
 590             ProjectionModeType ret = (ProjectionModeType)Interop.Camera.GetProjectionMode(SwigCPtr);
 591             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 592             return ret;
 593         }
 594
 595         internal void SetFieldOfView(float fieldOfView)
 596         {
 597             Interop.Camera.SetFieldOfView(SwigCPtr, fieldOfView);
 598             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 599         }
 600
 601         internal float GetFieldOfView()
 602         {
 603             float ret = Interop.Camera.GetFieldOfView(SwigCPtr);
 604             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 605             return ret;
 606         }
 607
 608         internal void SetAspectRatio(float aspectRatio)
 609         {
 610             Interop.Camera.SetAspectRatio(SwigCPtr, aspectRatio);
 611             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 612         }
 613
 614         internal float GetAspectRatio()
 615         {
 616             float ret = Interop.Camera.GetAspectRatio(SwigCPtr);
 617             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 618             return ret;
 619         }
 620
 621         internal void SetNearClippingPlane(float nearClippingPlane)
 622         {
 623             Interop.Camera.SetNearClippingPlane(SwigCPtr, nearClippingPlane);
 624             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 625         }
 626
 627         internal float GetNearClippingPlane()
 628         {
 629             float ret = Interop.Camera.GetNearClippingPlane(SwigCPtr);
 630             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 631             return ret;
 632         }
 633
 634         internal void SetFarClippingPlane(float farClippingPlane)
 635         {
 636             Interop.Camera.SetFarClippingPlane(SwigCPtr, farClippingPlane);
 637             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 638         }
 639
 640         internal float GetFarClippingPlane()
 641         {
 642             float ret = Interop.Camera.GetFarClippingPlane(SwigCPtr);
 643             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 644             return ret;
 645         }
 646
 647         internal void SetInvertYAxis(bool invertYAxis)
 648         {
 649             Interop.Camera.SetInvertYAxis(SwigCPtr, invertYAxis);
 650             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 651         }
 652
 653         internal bool GetInvertYAxis()
 654         {
 655             bool ret = Interop.Camera.GetInvertYAxis(SwigCPtr);
 656             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 657             return ret;
 658         }
 659
 660         /// <summary>
 661         /// Convert from vertical fov to horizontal fov consider with camera's AspectRatio.
 662         /// </summary>
 663         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 664         [EditorBrowsable(EditorBrowsableState.Never)]
 665         public static Radian ConvertFovFromVerticalToHorizontal(float aspect, Radian verticalFov)
 666         {
 667             if(verticalFov == null)
 668             {
 669                 return null;
 670             }
 671             return new Radian(2.0f * (float)Math.Atan(Math.Tan(verticalFov.ConvertToFloat() * 0.5f) * aspect));
 672         }
 673
 674         /// <summary>
 675         /// Convert from horizontal fov to vertical fov consider with camera's AspectRatio.
 676         /// </summary>
 677         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 678         [EditorBrowsable(EditorBrowsableState.Never)]
 679         public static Radian ConvertFovFromHorizontalToVertical(float aspect, Radian horizontalFov)
 680         {
 681             if(horizontalFov == null)
 682             {
 683                 return null;
 684             }
 685             return new Radian(2.0f * (float)Math.Atan(Math.Tan(horizontalFov.ConvertToFloat() * 0.5f) / aspect));
 686         }
 687
 688         /// <summary>
 689         /// Release swigCPtr.
 690         /// </summary>
 691         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 692         [EditorBrowsable(EditorBrowsableState.Never)]
 693         protected override void ReleaseSwigCPtr(global::System.Runtime.InteropServices.HandleRef swigCPtr)
 694         {
 695             Interop.Camera.DeleteCamera(swigCPtr);
 696         }
 697     }
 698 }