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