forked from OpenRA/OpenRA
-
Notifications
You must be signed in to change notification settings - Fork 0
/
decquat.glm.cs
212 lines (171 loc) · 8.48 KB
/
decquat.glm.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Numerics;
using System.Linq;
using GlmSharp.Swizzle;
// ReSharper disable InconsistentNaming
namespace GlmSharp
{
/// <summary>
/// Static class that contains static glm functions
/// </summary>
public static partial class glm
{
/// <summary>
/// Returns an array with all values
/// </summary>
public static decimal[] Values(decquat q) => q.Values;
/// <summary>
/// Returns an enumerator that iterates through all components.
/// </summary>
public static IEnumerator<decimal> GetEnumerator(decquat q) => q.GetEnumerator();
/// <summary>
/// Returns a string representation of this quaternion using ', ' as a seperator.
/// </summary>
public static string ToString(decquat q) => q.ToString();
/// <summary>
/// Returns a string representation of this quaternion using a provided seperator.
/// </summary>
public static string ToString(decquat q, string sep) => q.ToString(sep);
/// <summary>
/// Returns a string representation of this quaternion using a provided seperator and a format provider for each component.
/// </summary>
public static string ToString(decquat q, string sep, IFormatProvider provider) => q.ToString(sep, provider);
/// <summary>
/// Returns a string representation of this quaternion using a provided seperator and a format for each component.
/// </summary>
public static string ToString(decquat q, string sep, string format) => q.ToString(sep, format);
/// <summary>
/// Returns a string representation of this quaternion using a provided seperator and a format and format provider for each component.
/// </summary>
public static string ToString(decquat q, string sep, string format, IFormatProvider provider) => q.ToString(sep, format, provider);
/// <summary>
/// Returns the number of components (4).
/// </summary>
public static int Count(decquat q) => q.Count;
/// <summary>
/// Returns true iff this equals rhs component-wise.
/// </summary>
public static bool Equals(decquat q, decquat rhs) => q.Equals(rhs);
/// <summary>
/// Returns true iff this equals rhs type- and component-wise.
/// </summary>
public static bool Equals(decquat q, object obj) => q.Equals(obj);
/// <summary>
/// Returns a hash code for this instance.
/// </summary>
public static int GetHashCode(decquat q) => q.GetHashCode();
/// <summary>
/// Returns a bvec4 from component-wise application of Equal (lhs == rhs).
/// </summary>
public static bvec4 Equal(decquat lhs, decquat rhs) => decquat.Equal(lhs, rhs);
/// <summary>
/// Returns a bvec4 from component-wise application of NotEqual (lhs != rhs).
/// </summary>
public static bvec4 NotEqual(decquat lhs, decquat rhs) => decquat.NotEqual(lhs, rhs);
/// <summary>
/// Returns a bvec4 from component-wise application of GreaterThan (lhs > rhs).
/// </summary>
public static bvec4 GreaterThan(decquat lhs, decquat rhs) => decquat.GreaterThan(lhs, rhs);
/// <summary>
/// Returns a bvec4 from component-wise application of GreaterThanEqual (lhs >= rhs).
/// </summary>
public static bvec4 GreaterThanEqual(decquat lhs, decquat rhs) => decquat.GreaterThanEqual(lhs, rhs);
/// <summary>
/// Returns a bvec4 from component-wise application of LesserThan (lhs < rhs).
/// </summary>
public static bvec4 LesserThan(decquat lhs, decquat rhs) => decquat.LesserThan(lhs, rhs);
/// <summary>
/// Returns a bvec4 from component-wise application of LesserThanEqual (lhs <= rhs).
/// </summary>
public static bvec4 LesserThanEqual(decquat lhs, decquat rhs) => decquat.LesserThanEqual(lhs, rhs);
/// <summary>
/// Returns the inner product (dot product, scalar product) of the two quaternions.
/// </summary>
public static decimal Dot(decquat lhs, decquat rhs) => decquat.Dot(lhs, rhs);
/// <summary>
/// Returns the euclidean length of this quaternion.
/// </summary>
public static decimal Length(decquat q) => q.Length;
/// <summary>
/// Returns the squared euclidean length of this quaternion.
/// </summary>
public static decimal LengthSqr(decquat q) => q.LengthSqr;
/// <summary>
/// Returns a copy of this quaternion with length one (undefined if this has zero length).
/// </summary>
public static decquat Normalized(decquat q) => q.Normalized;
/// <summary>
/// Returns a copy of this quaternion with length one (returns zero if length is zero).
/// </summary>
public static decquat NormalizedSafe(decquat q) => q.NormalizedSafe;
/// <summary>
/// Returns the represented angle of this quaternion.
/// </summary>
public static double Angle(decquat q) => q.Angle;
/// <summary>
/// Returns the represented axis of this quaternion.
/// </summary>
public static decvec3 Axis(decquat q) => q.Axis;
/// <summary>
/// Returns the represented yaw angle of this quaternion.
/// </summary>
public static double Yaw(decquat q) => q.Yaw;
/// <summary>
/// Returns the represented pitch angle of this quaternion.
/// </summary>
public static double Pitch(decquat q) => q.Pitch;
/// <summary>
/// Returns the represented roll angle of this quaternion.
/// </summary>
public static double Roll(decquat q) => q.Roll;
/// <summary>
/// Returns the represented euler angles (pitch, yaw, roll) of this quaternion.
/// </summary>
public static dvec3 EulerAngles(decquat q) => q.EulerAngles;
/// <summary>
/// Rotates this quaternion from an axis and an angle (in radians).
/// </summary>
public static decquat Rotated(decquat q, decimal angle, decvec3 v) => q.Rotated(angle, v);
/// <summary>
/// Creates a decmat3 that realizes the rotation of this quaternion
/// </summary>
public static decmat3 ToMat3(decquat q) => q.ToMat3;
/// <summary>
/// Creates a decmat4 that realizes the rotation of this quaternion
/// </summary>
public static decmat4 ToMat4(decquat q) => q.ToMat4;
/// <summary>
/// Returns the conjugated quaternion
/// </summary>
public static decquat Conjugate(decquat q) => q.Conjugate;
/// <summary>
/// Returns the inverse quaternion
/// </summary>
public static decquat Inverse(decquat q) => q.Inverse;
/// <summary>
/// Returns the cross product between two quaternions.
/// </summary>
public static decquat Cross(decquat q1, decquat q2) => decquat.Cross(q1, q2);
/// <summary>
/// Calculates a proper spherical interpolation between two quaternions (only works for normalized quaternions).
/// </summary>
public static decquat Mix(decquat x, decquat y, decimal a) => decquat.Mix(x, y, a);
/// <summary>
/// Calculates a proper spherical interpolation between two quaternions (only works for normalized quaternions).
/// </summary>
public static decquat SLerp(decquat x, decquat y, decimal a) => decquat.SLerp(x, y, a);
/// <summary>
/// Applies squad interpolation of these quaternions
/// </summary>
public static decquat Squad(decquat q1, decquat q2, decquat s1, decquat s2, decimal h) => decquat.Squad(q1, q2, s1, s2, h);
/// <summary>
/// Returns a decquat from component-wise application of Lerp (min * (1-a) + max * a).
/// </summary>
public static decquat Lerp(decquat min, decquat max, decquat a) => decquat.Lerp(min, max, a);
}
}