src/Tizen.NUI/src/public/Rotation.cs

   1 /*
   2  * Copyright(c) 2017 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
  18 namespace Tizen.NUI
  19 {
  20
  21     /// <summary>
  22     /// The Rotation class.
  23     /// </summary>
  24     /// <since_tizen> 3 </since_tizen>
  25     public class Rotation : global::System.IDisposable
  26     {
  27         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  28         /// <summary>
  29         /// swigCMemOwn
  30         /// </summary>
  31         /// <since_tizen> 3 </since_tizen>
  32         protected bool swigCMemOwn;
  33
  34         internal Rotation(global::System.IntPtr cPtr, bool cMemoryOwn)
  35         {
  36             swigCMemOwn = cMemoryOwn;
  37             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  38         }
  39
  40         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Rotation obj)
  41         {
  42             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  43         }
  44
  45         //A Flag to check who called Dispose(). (By User or DisposeQueue)
  46         private bool isDisposeQueued = false;
  47         /// <summary>
  48         /// A Flat to check if it is already disposed.
  49         /// </summary>
  50         /// <since_tizen> 3 </since_tizen>
  51         protected bool disposed = false;
  52
  53         /// <summary>
  54         /// Dispose.
  55         /// </summary>
  56         /// <since_tizen> 3 </since_tizen>
  57         ~Rotation()
  58         {
  59             if(!isDisposeQueued)
  60             {
  61                 isDisposeQueued = true;
  62                 DisposeQueue.Instance.Add(this);
  63             }
  64         }
  65
  66         /// <summary>
  67         /// To make the Rotation instance be disposed.
  68         /// </summary>
  69         /// <since_tizen> 3 </since_tizen>
  70         public void Dispose()
  71         {
  72             //Throw excpetion if Dispose() is called in separate thread.
  73             if (!Window.IsInstalled())
  74             {
  75                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
  76             }
  77
  78             if (isDisposeQueued)
  79             {
  80                 Dispose(DisposeTypes.Implicit);
  81             }
  82             else
  83             {
  84                 Dispose(DisposeTypes.Explicit);
  85                 System.GC.SuppressFinalize(this);
  86             }
  87         }
  88
  89         /// <summary>
  90         /// Dispose.
  91         /// </summary>
  92         /// <since_tizen> 3 </since_tizen>
  93         protected virtual void Dispose(DisposeTypes type)
  94         {
  95             if (disposed)
  96             {
  97                 return;
  98             }
  99
 100             if(type == DisposeTypes.Explicit)
 101             {
 102                 //Called by User
 103                 //Release your own managed resources here.
 104                 //You should release all of your own disposable objects here.
 105             }
 106
 107             //Release your own unmanaged resources here.
 108             //You should not access any managed member here except static instance.
 109             //because the execution order of Finalizes is non-deterministic.
 110
 111             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 112             {
 113                 if (swigCMemOwn)
 114                 {
 115                     swigCMemOwn = false;
 116                     NDalicPINVOKE.delete_Rotation(swigCPtr);
 117                 }
 118                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 119             }
 120             disposed = true;
 121         }
 122
 123         /// <summary>
 124         /// The addition operator.
 125         /// </summary>
 126         /// <param name="arg1">The first rotation.</param>
 127         /// <param name="arg2">The second rotation.</param>
 128         /// <returns>The rotation containing the result of the addition.</returns>
 129         /// <since_tizen> 3 </since_tizen>
 130         public static Rotation operator +(Rotation arg1, Rotation arg2)
 131         {
 132             return arg1.Add(arg2);
 133         }
 134
 135         /// <summary>
 136         /// The subtraction operator.
 137         /// </summary>
 138         /// <param name="arg1">The first rotation.</param>
 139         /// <param name="arg2">The second rotation.</param>
 140         /// <returns>The rotation containing the result of the subtraction.</returns>
 141         /// <since_tizen> 3 </since_tizen>
 142         public static Rotation operator -(Rotation arg1, Rotation arg2)
 143         {
 144             return arg1.Subtract(arg2);
 145         }
 146
 147         /// <summary>
 148         /// The unary negation operator.
 149         /// </summary>
 150         /// <param name="arg1">The first rotation.</param>
 151         /// <returns>The rotation containing the negated result.</returns>
 152         /// <since_tizen> 3 </since_tizen>
 153         public static Rotation operator -(Rotation arg1)
 154         {
 155             return arg1.Subtract();
 156         }
 157
 158         /// <summary>
 159         /// The multiplication operator.
 160         /// </summary>
 161         /// <param name="arg1">The first rotation.</param>
 162         /// <param name="arg2">The second rotation.</param>
 163         /// <returns>The rotation containing the result of the multiplication.</returns>
 164         /// <since_tizen> 3 </since_tizen>
 165         public static Rotation operator *(Rotation arg1, Rotation arg2)
 166         {
 167             return arg1.Multiply(arg2);
 168         }
 169
 170         /// <summary>
 171         /// The multiplication operator.
 172         /// </summary>
 173         /// <param name="arg1">Rotation.</param>
 174         /// <param name="arg2">The vector to multiply.</param>
 175         /// <returns>The rotation containing the result of the multiplication.</returns>
 176         /// <since_tizen> 3 </since_tizen>
 177         public static Vector3 operator *(Rotation arg1, Vector3 arg2)
 178         {
 179             return arg1.Multiply(arg2);
 180         }
 181
 182         /// <summary>
 183         /// The scale operator.
 184         /// </summary>
 185         /// <param name="arg1">Rotation.</param>
 186         /// <param name="arg2">A value to scale by.</param>
 187         /// <returns>The rotation containing the result of scaling.</returns>
 188         /// <since_tizen> 3 </since_tizen>
 189         public static Rotation operator *(Rotation arg1, float arg2)
 190         {
 191             return arg1.Multiply(arg2);
 192         }
 193
 194         /// <summary>
 195         /// The division operator.
 196         /// </summary>
 197         /// <param name="arg1">The first rotation.</param>
 198         /// <param name="arg2">The second rotation.</param>
 199         /// <returns>The rotation containing the result of scaling.</returns>
 200         /// <since_tizen> 3 </since_tizen>
 201         public static Rotation operator /(Rotation arg1, Rotation arg2)
 202         {
 203             return arg1.Divide(arg2);
 204         }
 205
 206         /// <summary>
 207         /// The scale operator.
 208         /// </summary>
 209         /// <param name="arg1">Rotation.</param>
 210         /// <param name="arg2">A value to scale by.</param>
 211         /// <returns>The rotation containing the result of scaling.</returns>
 212         /// <since_tizen> 3 </since_tizen>
 213         public static Rotation operator /(Rotation arg1, float arg2)
 214         {
 215             return arg1.Divide(arg2);
 216         }
 217
 218         /// <summary>
 219         /// The default constructor.
 220         /// </summary>
 221         /// <since_tizen> 3 </since_tizen>
 222         public Rotation() : this(NDalicPINVOKE.new_Rotation__SWIG_0(), true)
 223         {
 224             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 225         }
 226
 227         /// <summary>
 228         /// The constructor from an axis and angle.
 229         /// </summary>
 230         /// <param name="angle">The angle around the axis.</param>
 231         /// <param name="axis">The vector of the axis.</param>
 232         /// <since_tizen> 3 </since_tizen>
 233         public Rotation(Radian angle, Vector3 axis) : this(NDalicPINVOKE.new_Rotation__SWIG_1(Radian.getCPtr(angle), Vector3.getCPtr(axis)), true)
 234         {
 235             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 236         }
 237
 238         /// <summary>
 239         /// (0.0f,0.0f,0.0f,1.0f).
 240         /// </summary>
 241         /// <since_tizen> 3 </since_tizen>
 242         public static Rotation IDENTITY
 243         {
 244             get
 245             {
 246                 global::System.IntPtr cPtr = NDalicPINVOKE.Rotation_IDENTITY_get();
 247                 Rotation ret = (cPtr == global::System.IntPtr.Zero) ? null : new Rotation(cPtr, false);
 248                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 249                 return ret;
 250             }
 251         }
 252
 253         /// <summary>
 254         /// Helper to check if this is an identity quaternion.
 255         /// </summary>
 256         /// <returns>True if this is identity quaternion.</returns>
 257         /// <since_tizen> 3 </since_tizen>
 258         public bool IsIdentity()
 259         {
 260             bool ret = NDalicPINVOKE.Rotation_IsIdentity(swigCPtr);
 261             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 262             return ret;
 263         }
 264
 265         /// <summary>
 266         /// Converts the quaternion to an axis or angle pair.
 267         /// </summary>
 268         /// <param name="axis">The result of an an axis.</param>
 269         /// <param name="angle">The result of angle in radians.</param>
 270         /// <returns>True if converted correctly.</returns>
 271         /// <since_tizen> 3 </since_tizen>
 272         public bool GetAxisAngle(Vector3 axis, Radian angle)
 273         {
 274             bool ret = NDalicPINVOKE.Rotation_GetAxisAngle(swigCPtr, Vector3.getCPtr(axis), Radian.getCPtr(angle));
 275             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 276             return ret;
 277         }
 278
 279         private Rotation Add(Rotation other)
 280         {
 281             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Add(swigCPtr, Rotation.getCPtr(other)), true);
 282             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 283             return ret;
 284         }
 285
 286         private Rotation Subtract(Rotation other)
 287         {
 288             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Subtract__SWIG_0(swigCPtr, Rotation.getCPtr(other)), true);
 289             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 290             return ret;
 291         }
 292
 293         private Rotation Multiply(Rotation other)
 294         {
 295             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Multiply__SWIG_0(swigCPtr, Rotation.getCPtr(other)), true);
 296             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 297             return ret;
 298         }
 299
 300         private Vector3 Multiply(Vector3 other)
 301         {
 302             Vector3 ret = new Vector3(NDalicPINVOKE.Rotation_Multiply__SWIG_1(swigCPtr, Vector3.getCPtr(other)), true);
 303             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 304             return ret;
 305         }
 306
 307         private Rotation Divide(Rotation other)
 308         {
 309             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Divide__SWIG_0(swigCPtr, Rotation.getCPtr(other)), true);
 310             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 311             return ret;
 312         }
 313
 314         private Rotation Multiply(float scale)
 315         {
 316             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Multiply__SWIG_2(swigCPtr, scale), true);
 317             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 318             return ret;
 319         }
 320
 321         private Rotation Divide(float scale)
 322         {
 323             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Divide__SWIG_1(swigCPtr, scale), true);
 324             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 325             return ret;
 326         }
 327
 328         private Rotation Subtract()
 329         {
 330             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Subtract__SWIG_1(swigCPtr), true);
 331             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 332             return ret;
 333         }
 334
 335         private Rotation AddAssign(Rotation other)
 336         {
 337             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_AddAssign(swigCPtr, Rotation.getCPtr(other)), false);
 338             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 339             return ret;
 340         }
 341
 342         private Rotation SubtractAssign(Rotation other)
 343         {
 344             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_SubtractAssign(swigCPtr, Rotation.getCPtr(other)), false);
 345             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 346             return ret;
 347         }
 348
 349         private Rotation MultiplyAssign(Rotation other)
 350         {
 351             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_MultiplyAssign__SWIG_0(swigCPtr, Rotation.getCPtr(other)), false);
 352             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 353             return ret;
 354         }
 355
 356         private Rotation MultiplyAssign(float scale)
 357         {
 358             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_MultiplyAssign__SWIG_1(swigCPtr, scale), false);
 359             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 360             return ret;
 361         }
 362
 363         private Rotation DivideAssign(float scale)
 364         {
 365             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_DivideAssign(swigCPtr, scale), false);
 366             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 367             return ret;
 368         }
 369
 370         private bool EqualTo(Rotation rhs)
 371         {
 372             bool ret = NDalicPINVOKE.Rotation_EqualTo(swigCPtr, Rotation.getCPtr(rhs));
 373             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 374             return ret;
 375         }
 376
 377         private bool NotEqualTo(Rotation rhs)
 378         {
 379             bool ret = NDalicPINVOKE.Rotation_NotEqualTo(swigCPtr, Rotation.getCPtr(rhs));
 380             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 381             return ret;
 382         }
 383
 384         /// <summary>
 385         /// Returns the length of the rotation.
 386         /// </summary>
 387         /// <returns>The length of the rotation.</returns>
 388         /// <since_tizen> 3 </since_tizen>
 389         public float Length()
 390         {
 391             float ret = NDalicPINVOKE.Rotation_Length(swigCPtr);
 392             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 393             return ret;
 394         }
 395
 396         /// <summary>
 397         /// Returns the squared length of the rotation.
 398         /// </summary>
 399         /// <returns>The squared length of the rotation.</returns>
 400         /// <since_tizen> 3 </since_tizen>
 401         public float LengthSquared()
 402         {
 403             float ret = NDalicPINVOKE.Rotation_LengthSquared(swigCPtr);
 404             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 405             return ret;
 406         }
 407
 408         /// <summary>
 409         /// Normalizes this to unit length.
 410         /// </summary>
 411         /// <since_tizen> 3 </since_tizen>
 412         public void Normalize()
 413         {
 414             NDalicPINVOKE.Rotation_Normalize(swigCPtr);
 415             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 416         }
 417
 418         /// <summary>
 419         /// Normalized.
 420         /// </summary>
 421         /// <returns>A normalized version of this rotation.</returns>
 422         /// <since_tizen> 3 </since_tizen>
 423         public Rotation Normalized()
 424         {
 425             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Normalized(swigCPtr), true);
 426             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 427             return ret;
 428         }
 429
 430         /// <summary>
 431         /// Conjugates this rotation.
 432         /// </summary>
 433         /// <since_tizen> 3 </since_tizen>
 434         public void Conjugate()
 435         {
 436             NDalicPINVOKE.Rotation_Conjugate(swigCPtr);
 437             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 438         }
 439
 440         /// <summary>
 441         /// Inverts this rotation.
 442         /// </summary>
 443         /// <since_tizen> 3 </since_tizen>
 444         public void Invert()
 445         {
 446             NDalicPINVOKE.Rotation_Invert(swigCPtr);
 447             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 448         }
 449
 450         /// <summary>
 451         /// Performs the logarithm of a rotation.
 452         /// </summary>
 453         /// <returns>The rotation representing the logarithm.</returns>
 454         /// <since_tizen> 3 </since_tizen>
 455         public Rotation Log()
 456         {
 457             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Log(swigCPtr), true);
 458             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 459             return ret;
 460         }
 461
 462         /// <summary>
 463         /// Performs an exponent.
 464         /// </summary>
 465         /// <returns>The rotation representing the exponent.</returns>
 466         /// <since_tizen> 3 </since_tizen>
 467         public Rotation Exp()
 468         {
 469             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Exp(swigCPtr), true);
 470             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 471             return ret;
 472         }
 473
 474         /// <summary>
 475         /// Returns the dot product of two rotations.
 476         /// </summary>
 477         /// <param name="q1">The first rotation.</param>
 478         /// <param name="q2">The second rotation.</param>
 479         /// <returns>The dot product of the two rotations.</returns>
 480         /// <since_tizen> 3 </since_tizen>
 481         public static float Dot(Rotation q1, Rotation q2)
 482         {
 483             float ret = NDalicPINVOKE.Rotation_Dot(Rotation.getCPtr(q1), Rotation.getCPtr(q2));
 484             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 485             return ret;
 486         }
 487
 488         /// <summary>
 489         /// The linear iterpolation (using a straight line between the two rotations).
 490         /// </summary>
 491         /// <param name="q1">The start rotation.</param>
 492         /// <param name="q2">The end rotation.</param>
 493         /// <param name="t">A progress value between 0 and 1.</param>
 494         /// <returns>The interpolated rotation.</returns>
 495         /// <since_tizen> 3 </since_tizen>
 496         public static Rotation Lerp(Rotation q1, Rotation q2, float t)
 497         {
 498             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Lerp(Rotation.getCPtr(q1), Rotation.getCPtr(q2), t), true);
 499             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 500             return ret;
 501         }
 502
 503         /// <summary>
 504         /// The spherical linear interpolation (using the shortest arc of a great circle between the two rotations).
 505         /// </summary>
 506         /// <param name="q1">The start rotation.</param>
 507         /// <param name="q2">The end rotation.</param>
 508         /// <param name="progress">A progress value between 0 and 1.</param>
 509         /// <returns>The interpolated rotation.</returns>
 510         /// <since_tizen> 3 </since_tizen>
 511         public static Rotation Slerp(Rotation q1, Rotation q2, float progress)
 512         {
 513             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Slerp(Rotation.getCPtr(q1), Rotation.getCPtr(q2), progress), true);
 514             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 515             return ret;
 516         }
 517
 518         /// <summary>
 519         /// This version of slerp, used by squad, does not check for theta > 90.
 520         /// </summary>
 521         /// <param name="q1">The start rotation.</param>
 522         /// <param name="q2">The end rotation.</param>
 523         /// <param name="t">A progress value between 0 and 1.</param>
 524         /// <returns>The interpolated rotation.</returns>
 525         /// <since_tizen> 3 </since_tizen>
 526         public static Rotation SlerpNoInvert(Rotation q1, Rotation q2, float t)
 527         {
 528             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_SlerpNoInvert(Rotation.getCPtr(q1), Rotation.getCPtr(q2), t), true);
 529             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 530             return ret;
 531         }
 532
 533         /// <summary>
 534         /// The spherical cubic interpolation.
 535         /// </summary>
 536         /// <param name="start">The start rotation.</param>
 537         /// <param name="end">The end rotation.</param>
 538         /// <param name="ctrl1">The control rotation for q1.</param>
 539         /// <param name="ctrl2">The control rotation for q2.</param>
 540         /// <param name="t">A progress value between 0 and 1.</param>
 541         /// <returns>The interpolated rotation.</returns>
 542         /// <since_tizen> 3 </since_tizen>
 543         public static Rotation Squad(Rotation start, Rotation end, Rotation ctrl1, Rotation ctrl2, float t)
 544         {
 545             Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Squad(Rotation.getCPtr(start), Rotation.getCPtr(end), Rotation.getCPtr(ctrl1), Rotation.getCPtr(ctrl2), t), true);
 546             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 547             return ret;
 548         }
 549
 550         /// <summary>
 551         /// Returns the shortest angle between two rotations in radians.
 552         /// </summary>
 553         /// <param name="q1">The first rotation.</param>
 554         /// <param name="q2">The second rotation.</param>
 555         /// <returns>The angle between the two rotation.</returns>
 556         /// <since_tizen> 3 </since_tizen>
 557         public static float AngleBetween(Rotation q1, Rotation q2)
 558         {
 559             float ret = NDalicPINVOKE.Rotation_AngleBetween(Rotation.getCPtr(q1), Rotation.getCPtr(q2));
 560             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 561             return ret;
 562         }
 563
 564     }
 565
 566 }