A game about forced loneliness, made by TACStudios
tacstudios.tngl.sh
1//------------------------------------------------------------------------------
2// <auto-generated>
3// This code was generated by a tool.
4//
5// Changes to this file may cause incorrect behavior and will be lost if
6// the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
7// </auto-generated>
8//------------------------------------------------------------------------------
9using System;
10using System.Runtime.CompilerServices;
11using Unity.IL2CPP.CompilerServices;
12
13#pragma warning disable 0660, 0661
14
15namespace Unity.Mathematics
16{
17 /// <summary>A 4x4 matrix of floats.</summary>
18 [System.Serializable]
19 [Il2CppEagerStaticClassConstruction]
20 public partial struct float4x4 : System.IEquatable<float4x4>, IFormattable
21 {
22 /// <summary>Column 0 of the matrix.</summary>
23 public float4 c0;
24 /// <summary>Column 1 of the matrix.</summary>
25 public float4 c1;
26 /// <summary>Column 2 of the matrix.</summary>
27 public float4 c2;
28 /// <summary>Column 3 of the matrix.</summary>
29 public float4 c3;
30
31 /// <summary>float4x4 identity transform.</summary>
32 public static readonly float4x4 identity = new float4x4(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f);
33
34 /// <summary>float4x4 zero value.</summary>
35 public static readonly float4x4 zero;
36
37 /// <summary>Constructs a float4x4 matrix from four float4 vectors.</summary>
38 /// <param name="c0">The matrix column c0 will be set to this value.</param>
39 /// <param name="c1">The matrix column c1 will be set to this value.</param>
40 /// <param name="c2">The matrix column c2 will be set to this value.</param>
41 /// <param name="c3">The matrix column c3 will be set to this value.</param>
42 [MethodImpl(MethodImplOptions.AggressiveInlining)]
43 public float4x4(float4 c0, float4 c1, float4 c2, float4 c3)
44 {
45 this.c0 = c0;
46 this.c1 = c1;
47 this.c2 = c2;
48 this.c3 = c3;
49 }
50
51 /// <summary>Constructs a float4x4 matrix from 16 float values given in row-major order.</summary>
52 /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
53 /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
54 /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
55 /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
56 /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
57 /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
58 /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
59 /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
60 /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
61 /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
62 /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
63 /// <param name="m23">The matrix at row 2, column 3 will be set to this value.</param>
64 /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
65 /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
66 /// <param name="m32">The matrix at row 3, column 2 will be set to this value.</param>
67 /// <param name="m33">The matrix at row 3, column 3 will be set to this value.</param>
68 [MethodImpl(MethodImplOptions.AggressiveInlining)]
69 public float4x4(float m00, float m01, float m02, float m03,
70 float m10, float m11, float m12, float m13,
71 float m20, float m21, float m22, float m23,
72 float m30, float m31, float m32, float m33)
73 {
74 this.c0 = new float4(m00, m10, m20, m30);
75 this.c1 = new float4(m01, m11, m21, m31);
76 this.c2 = new float4(m02, m12, m22, m32);
77 this.c3 = new float4(m03, m13, m23, m33);
78 }
79
80 /// <summary>Constructs a float4x4 matrix from a single float value by assigning it to every component.</summary>
81 /// <param name="v">float to convert to float4x4</param>
82 [MethodImpl(MethodImplOptions.AggressiveInlining)]
83 public float4x4(float v)
84 {
85 this.c0 = v;
86 this.c1 = v;
87 this.c2 = v;
88 this.c3 = v;
89 }
90
91 /// <summary>Constructs a float4x4 matrix from a single bool value by converting it to float and assigning it to every component.</summary>
92 /// <param name="v">bool to convert to float4x4</param>
93 [MethodImpl(MethodImplOptions.AggressiveInlining)]
94 public float4x4(bool v)
95 {
96 this.c0 = math.select(new float4(0.0f), new float4(1.0f), v);
97 this.c1 = math.select(new float4(0.0f), new float4(1.0f), v);
98 this.c2 = math.select(new float4(0.0f), new float4(1.0f), v);
99 this.c3 = math.select(new float4(0.0f), new float4(1.0f), v);
100 }
101
102 /// <summary>Constructs a float4x4 matrix from a bool4x4 matrix by componentwise conversion.</summary>
103 /// <param name="v">bool4x4 to convert to float4x4</param>
104 [MethodImpl(MethodImplOptions.AggressiveInlining)]
105 public float4x4(bool4x4 v)
106 {
107 this.c0 = math.select(new float4(0.0f), new float4(1.0f), v.c0);
108 this.c1 = math.select(new float4(0.0f), new float4(1.0f), v.c1);
109 this.c2 = math.select(new float4(0.0f), new float4(1.0f), v.c2);
110 this.c3 = math.select(new float4(0.0f), new float4(1.0f), v.c3);
111 }
112
113 /// <summary>Constructs a float4x4 matrix from a single int value by converting it to float and assigning it to every component.</summary>
114 /// <param name="v">int to convert to float4x4</param>
115 [MethodImpl(MethodImplOptions.AggressiveInlining)]
116 public float4x4(int v)
117 {
118 this.c0 = v;
119 this.c1 = v;
120 this.c2 = v;
121 this.c3 = v;
122 }
123
124 /// <summary>Constructs a float4x4 matrix from a int4x4 matrix by componentwise conversion.</summary>
125 /// <param name="v">int4x4 to convert to float4x4</param>
126 [MethodImpl(MethodImplOptions.AggressiveInlining)]
127 public float4x4(int4x4 v)
128 {
129 this.c0 = v.c0;
130 this.c1 = v.c1;
131 this.c2 = v.c2;
132 this.c3 = v.c3;
133 }
134
135 /// <summary>Constructs a float4x4 matrix from a single uint value by converting it to float and assigning it to every component.</summary>
136 /// <param name="v">uint to convert to float4x4</param>
137 [MethodImpl(MethodImplOptions.AggressiveInlining)]
138 public float4x4(uint v)
139 {
140 this.c0 = v;
141 this.c1 = v;
142 this.c2 = v;
143 this.c3 = v;
144 }
145
146 /// <summary>Constructs a float4x4 matrix from a uint4x4 matrix by componentwise conversion.</summary>
147 /// <param name="v">uint4x4 to convert to float4x4</param>
148 [MethodImpl(MethodImplOptions.AggressiveInlining)]
149 public float4x4(uint4x4 v)
150 {
151 this.c0 = v.c0;
152 this.c1 = v.c1;
153 this.c2 = v.c2;
154 this.c3 = v.c3;
155 }
156
157 /// <summary>Constructs a float4x4 matrix from a single double value by converting it to float and assigning it to every component.</summary>
158 /// <param name="v">double to convert to float4x4</param>
159 [MethodImpl(MethodImplOptions.AggressiveInlining)]
160 public float4x4(double v)
161 {
162 this.c0 = (float4)v;
163 this.c1 = (float4)v;
164 this.c2 = (float4)v;
165 this.c3 = (float4)v;
166 }
167
168 /// <summary>Constructs a float4x4 matrix from a double4x4 matrix by componentwise conversion.</summary>
169 /// <param name="v">double4x4 to convert to float4x4</param>
170 [MethodImpl(MethodImplOptions.AggressiveInlining)]
171 public float4x4(double4x4 v)
172 {
173 this.c0 = (float4)v.c0;
174 this.c1 = (float4)v.c1;
175 this.c2 = (float4)v.c2;
176 this.c3 = (float4)v.c3;
177 }
178
179
180 /// <summary>Implicitly converts a single float value to a float4x4 matrix by assigning it to every component.</summary>
181 /// <param name="v">float to convert to float4x4</param>
182 /// <returns>Converted value.</returns>
183 [MethodImpl(MethodImplOptions.AggressiveInlining)]
184 public static implicit operator float4x4(float v) { return new float4x4(v); }
185
186 /// <summary>Explicitly converts a single bool value to a float4x4 matrix by converting it to float and assigning it to every component.</summary>
187 /// <param name="v">bool to convert to float4x4</param>
188 /// <returns>Converted value.</returns>
189 [MethodImpl(MethodImplOptions.AggressiveInlining)]
190 public static explicit operator float4x4(bool v) { return new float4x4(v); }
191
192 /// <summary>Explicitly converts a bool4x4 matrix to a float4x4 matrix by componentwise conversion.</summary>
193 /// <param name="v">bool4x4 to convert to float4x4</param>
194 /// <returns>Converted value.</returns>
195 [MethodImpl(MethodImplOptions.AggressiveInlining)]
196 public static explicit operator float4x4(bool4x4 v) { return new float4x4(v); }
197
198 /// <summary>Implicitly converts a single int value to a float4x4 matrix by converting it to float and assigning it to every component.</summary>
199 /// <param name="v">int to convert to float4x4</param>
200 /// <returns>Converted value.</returns>
201 [MethodImpl(MethodImplOptions.AggressiveInlining)]
202 public static implicit operator float4x4(int v) { return new float4x4(v); }
203
204 /// <summary>Implicitly converts a int4x4 matrix to a float4x4 matrix by componentwise conversion.</summary>
205 /// <param name="v">int4x4 to convert to float4x4</param>
206 /// <returns>Converted value.</returns>
207 [MethodImpl(MethodImplOptions.AggressiveInlining)]
208 public static implicit operator float4x4(int4x4 v) { return new float4x4(v); }
209
210 /// <summary>Implicitly converts a single uint value to a float4x4 matrix by converting it to float and assigning it to every component.</summary>
211 /// <param name="v">uint to convert to float4x4</param>
212 /// <returns>Converted value.</returns>
213 [MethodImpl(MethodImplOptions.AggressiveInlining)]
214 public static implicit operator float4x4(uint v) { return new float4x4(v); }
215
216 /// <summary>Implicitly converts a uint4x4 matrix to a float4x4 matrix by componentwise conversion.</summary>
217 /// <param name="v">uint4x4 to convert to float4x4</param>
218 /// <returns>Converted value.</returns>
219 [MethodImpl(MethodImplOptions.AggressiveInlining)]
220 public static implicit operator float4x4(uint4x4 v) { return new float4x4(v); }
221
222 /// <summary>Explicitly converts a single double value to a float4x4 matrix by converting it to float and assigning it to every component.</summary>
223 /// <param name="v">double to convert to float4x4</param>
224 /// <returns>Converted value.</returns>
225 [MethodImpl(MethodImplOptions.AggressiveInlining)]
226 public static explicit operator float4x4(double v) { return new float4x4(v); }
227
228 /// <summary>Explicitly converts a double4x4 matrix to a float4x4 matrix by componentwise conversion.</summary>
229 /// <param name="v">double4x4 to convert to float4x4</param>
230 /// <returns>Converted value.</returns>
231 [MethodImpl(MethodImplOptions.AggressiveInlining)]
232 public static explicit operator float4x4(double4x4 v) { return new float4x4(v); }
233
234
235 /// <summary>Returns the result of a componentwise multiplication operation on two float4x4 matrices.</summary>
236 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise multiplication.</param>
237 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise multiplication.</param>
238 /// <returns>float4x4 result of the componentwise multiplication.</returns>
239 [MethodImpl(MethodImplOptions.AggressiveInlining)]
240 public static float4x4 operator * (float4x4 lhs, float4x4 rhs) { return new float4x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); }
241
242 /// <summary>Returns the result of a componentwise multiplication operation on a float4x4 matrix and a float value.</summary>
243 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise multiplication.</param>
244 /// <param name="rhs">Right hand side float to use to compute componentwise multiplication.</param>
245 /// <returns>float4x4 result of the componentwise multiplication.</returns>
246 [MethodImpl(MethodImplOptions.AggressiveInlining)]
247 public static float4x4 operator * (float4x4 lhs, float rhs) { return new float4x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); }
248
249 /// <summary>Returns the result of a componentwise multiplication operation on a float value and a float4x4 matrix.</summary>
250 /// <param name="lhs">Left hand side float to use to compute componentwise multiplication.</param>
251 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise multiplication.</param>
252 /// <returns>float4x4 result of the componentwise multiplication.</returns>
253 [MethodImpl(MethodImplOptions.AggressiveInlining)]
254 public static float4x4 operator * (float lhs, float4x4 rhs) { return new float4x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); }
255
256
257 /// <summary>Returns the result of a componentwise addition operation on two float4x4 matrices.</summary>
258 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise addition.</param>
259 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise addition.</param>
260 /// <returns>float4x4 result of the componentwise addition.</returns>
261 [MethodImpl(MethodImplOptions.AggressiveInlining)]
262 public static float4x4 operator + (float4x4 lhs, float4x4 rhs) { return new float4x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); }
263
264 /// <summary>Returns the result of a componentwise addition operation on a float4x4 matrix and a float value.</summary>
265 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise addition.</param>
266 /// <param name="rhs">Right hand side float to use to compute componentwise addition.</param>
267 /// <returns>float4x4 result of the componentwise addition.</returns>
268 [MethodImpl(MethodImplOptions.AggressiveInlining)]
269 public static float4x4 operator + (float4x4 lhs, float rhs) { return new float4x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); }
270
271 /// <summary>Returns the result of a componentwise addition operation on a float value and a float4x4 matrix.</summary>
272 /// <param name="lhs">Left hand side float to use to compute componentwise addition.</param>
273 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise addition.</param>
274 /// <returns>float4x4 result of the componentwise addition.</returns>
275 [MethodImpl(MethodImplOptions.AggressiveInlining)]
276 public static float4x4 operator + (float lhs, float4x4 rhs) { return new float4x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); }
277
278
279 /// <summary>Returns the result of a componentwise subtraction operation on two float4x4 matrices.</summary>
280 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise subtraction.</param>
281 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise subtraction.</param>
282 /// <returns>float4x4 result of the componentwise subtraction.</returns>
283 [MethodImpl(MethodImplOptions.AggressiveInlining)]
284 public static float4x4 operator - (float4x4 lhs, float4x4 rhs) { return new float4x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); }
285
286 /// <summary>Returns the result of a componentwise subtraction operation on a float4x4 matrix and a float value.</summary>
287 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise subtraction.</param>
288 /// <param name="rhs">Right hand side float to use to compute componentwise subtraction.</param>
289 /// <returns>float4x4 result of the componentwise subtraction.</returns>
290 [MethodImpl(MethodImplOptions.AggressiveInlining)]
291 public static float4x4 operator - (float4x4 lhs, float rhs) { return new float4x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); }
292
293 /// <summary>Returns the result of a componentwise subtraction operation on a float value and a float4x4 matrix.</summary>
294 /// <param name="lhs">Left hand side float to use to compute componentwise subtraction.</param>
295 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise subtraction.</param>
296 /// <returns>float4x4 result of the componentwise subtraction.</returns>
297 [MethodImpl(MethodImplOptions.AggressiveInlining)]
298 public static float4x4 operator - (float lhs, float4x4 rhs) { return new float4x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); }
299
300
301 /// <summary>Returns the result of a componentwise division operation on two float4x4 matrices.</summary>
302 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise division.</param>
303 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise division.</param>
304 /// <returns>float4x4 result of the componentwise division.</returns>
305 [MethodImpl(MethodImplOptions.AggressiveInlining)]
306 public static float4x4 operator / (float4x4 lhs, float4x4 rhs) { return new float4x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); }
307
308 /// <summary>Returns the result of a componentwise division operation on a float4x4 matrix and a float value.</summary>
309 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise division.</param>
310 /// <param name="rhs">Right hand side float to use to compute componentwise division.</param>
311 /// <returns>float4x4 result of the componentwise division.</returns>
312 [MethodImpl(MethodImplOptions.AggressiveInlining)]
313 public static float4x4 operator / (float4x4 lhs, float rhs) { return new float4x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); }
314
315 /// <summary>Returns the result of a componentwise division operation on a float value and a float4x4 matrix.</summary>
316 /// <param name="lhs">Left hand side float to use to compute componentwise division.</param>
317 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise division.</param>
318 /// <returns>float4x4 result of the componentwise division.</returns>
319 [MethodImpl(MethodImplOptions.AggressiveInlining)]
320 public static float4x4 operator / (float lhs, float4x4 rhs) { return new float4x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); }
321
322
323 /// <summary>Returns the result of a componentwise modulus operation on two float4x4 matrices.</summary>
324 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise modulus.</param>
325 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise modulus.</param>
326 /// <returns>float4x4 result of the componentwise modulus.</returns>
327 [MethodImpl(MethodImplOptions.AggressiveInlining)]
328 public static float4x4 operator % (float4x4 lhs, float4x4 rhs) { return new float4x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); }
329
330 /// <summary>Returns the result of a componentwise modulus operation on a float4x4 matrix and a float value.</summary>
331 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise modulus.</param>
332 /// <param name="rhs">Right hand side float to use to compute componentwise modulus.</param>
333 /// <returns>float4x4 result of the componentwise modulus.</returns>
334 [MethodImpl(MethodImplOptions.AggressiveInlining)]
335 public static float4x4 operator % (float4x4 lhs, float rhs) { return new float4x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); }
336
337 /// <summary>Returns the result of a componentwise modulus operation on a float value and a float4x4 matrix.</summary>
338 /// <param name="lhs">Left hand side float to use to compute componentwise modulus.</param>
339 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise modulus.</param>
340 /// <returns>float4x4 result of the componentwise modulus.</returns>
341 [MethodImpl(MethodImplOptions.AggressiveInlining)]
342 public static float4x4 operator % (float lhs, float4x4 rhs) { return new float4x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); }
343
344
345 /// <summary>Returns the result of a componentwise increment operation on a float4x4 matrix.</summary>
346 /// <param name="val">Value to use when computing the componentwise increment.</param>
347 /// <returns>float4x4 result of the componentwise increment.</returns>
348 [MethodImpl(MethodImplOptions.AggressiveInlining)]
349 public static float4x4 operator ++ (float4x4 val) { return new float4x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
350
351
352 /// <summary>Returns the result of a componentwise decrement operation on a float4x4 matrix.</summary>
353 /// <param name="val">Value to use when computing the componentwise decrement.</param>
354 /// <returns>float4x4 result of the componentwise decrement.</returns>
355 [MethodImpl(MethodImplOptions.AggressiveInlining)]
356 public static float4x4 operator -- (float4x4 val) { return new float4x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
357
358
359 /// <summary>Returns the result of a componentwise less than operation on two float4x4 matrices.</summary>
360 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise less than.</param>
361 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise less than.</param>
362 /// <returns>bool4x4 result of the componentwise less than.</returns>
363 [MethodImpl(MethodImplOptions.AggressiveInlining)]
364 public static bool4x4 operator < (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); }
365
366 /// <summary>Returns the result of a componentwise less than operation on a float4x4 matrix and a float value.</summary>
367 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise less than.</param>
368 /// <param name="rhs">Right hand side float to use to compute componentwise less than.</param>
369 /// <returns>bool4x4 result of the componentwise less than.</returns>
370 [MethodImpl(MethodImplOptions.AggressiveInlining)]
371 public static bool4x4 operator < (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); }
372
373 /// <summary>Returns the result of a componentwise less than operation on a float value and a float4x4 matrix.</summary>
374 /// <param name="lhs">Left hand side float to use to compute componentwise less than.</param>
375 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise less than.</param>
376 /// <returns>bool4x4 result of the componentwise less than.</returns>
377 [MethodImpl(MethodImplOptions.AggressiveInlining)]
378 public static bool4x4 operator < (float lhs, float4x4 rhs) { return new bool4x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); }
379
380
381 /// <summary>Returns the result of a componentwise less or equal operation on two float4x4 matrices.</summary>
382 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise less or equal.</param>
383 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise less or equal.</param>
384 /// <returns>bool4x4 result of the componentwise less or equal.</returns>
385 [MethodImpl(MethodImplOptions.AggressiveInlining)]
386 public static bool4x4 operator <= (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); }
387
388 /// <summary>Returns the result of a componentwise less or equal operation on a float4x4 matrix and a float value.</summary>
389 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise less or equal.</param>
390 /// <param name="rhs">Right hand side float to use to compute componentwise less or equal.</param>
391 /// <returns>bool4x4 result of the componentwise less or equal.</returns>
392 [MethodImpl(MethodImplOptions.AggressiveInlining)]
393 public static bool4x4 operator <= (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); }
394
395 /// <summary>Returns the result of a componentwise less or equal operation on a float value and a float4x4 matrix.</summary>
396 /// <param name="lhs">Left hand side float to use to compute componentwise less or equal.</param>
397 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise less or equal.</param>
398 /// <returns>bool4x4 result of the componentwise less or equal.</returns>
399 [MethodImpl(MethodImplOptions.AggressiveInlining)]
400 public static bool4x4 operator <= (float lhs, float4x4 rhs) { return new bool4x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); }
401
402
403 /// <summary>Returns the result of a componentwise greater than operation on two float4x4 matrices.</summary>
404 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise greater than.</param>
405 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise greater than.</param>
406 /// <returns>bool4x4 result of the componentwise greater than.</returns>
407 [MethodImpl(MethodImplOptions.AggressiveInlining)]
408 public static bool4x4 operator > (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); }
409
410 /// <summary>Returns the result of a componentwise greater than operation on a float4x4 matrix and a float value.</summary>
411 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise greater than.</param>
412 /// <param name="rhs">Right hand side float to use to compute componentwise greater than.</param>
413 /// <returns>bool4x4 result of the componentwise greater than.</returns>
414 [MethodImpl(MethodImplOptions.AggressiveInlining)]
415 public static bool4x4 operator > (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); }
416
417 /// <summary>Returns the result of a componentwise greater than operation on a float value and a float4x4 matrix.</summary>
418 /// <param name="lhs">Left hand side float to use to compute componentwise greater than.</param>
419 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise greater than.</param>
420 /// <returns>bool4x4 result of the componentwise greater than.</returns>
421 [MethodImpl(MethodImplOptions.AggressiveInlining)]
422 public static bool4x4 operator > (float lhs, float4x4 rhs) { return new bool4x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); }
423
424
425 /// <summary>Returns the result of a componentwise greater or equal operation on two float4x4 matrices.</summary>
426 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise greater or equal.</param>
427 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise greater or equal.</param>
428 /// <returns>bool4x4 result of the componentwise greater or equal.</returns>
429 [MethodImpl(MethodImplOptions.AggressiveInlining)]
430 public static bool4x4 operator >= (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); }
431
432 /// <summary>Returns the result of a componentwise greater or equal operation on a float4x4 matrix and a float value.</summary>
433 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise greater or equal.</param>
434 /// <param name="rhs">Right hand side float to use to compute componentwise greater or equal.</param>
435 /// <returns>bool4x4 result of the componentwise greater or equal.</returns>
436 [MethodImpl(MethodImplOptions.AggressiveInlining)]
437 public static bool4x4 operator >= (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); }
438
439 /// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float4x4 matrix.</summary>
440 /// <param name="lhs">Left hand side float to use to compute componentwise greater or equal.</param>
441 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise greater or equal.</param>
442 /// <returns>bool4x4 result of the componentwise greater or equal.</returns>
443 [MethodImpl(MethodImplOptions.AggressiveInlining)]
444 public static bool4x4 operator >= (float lhs, float4x4 rhs) { return new bool4x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); }
445
446
447 /// <summary>Returns the result of a componentwise unary minus operation on a float4x4 matrix.</summary>
448 /// <param name="val">Value to use when computing the componentwise unary minus.</param>
449 /// <returns>float4x4 result of the componentwise unary minus.</returns>
450 [MethodImpl(MethodImplOptions.AggressiveInlining)]
451 public static float4x4 operator - (float4x4 val) { return new float4x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
452
453
454 /// <summary>Returns the result of a componentwise unary plus operation on a float4x4 matrix.</summary>
455 /// <param name="val">Value to use when computing the componentwise unary plus.</param>
456 /// <returns>float4x4 result of the componentwise unary plus.</returns>
457 [MethodImpl(MethodImplOptions.AggressiveInlining)]
458 public static float4x4 operator + (float4x4 val) { return new float4x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
459
460
461 /// <summary>Returns the result of a componentwise equality operation on two float4x4 matrices.</summary>
462 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise equality.</param>
463 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise equality.</param>
464 /// <returns>bool4x4 result of the componentwise equality.</returns>
465 [MethodImpl(MethodImplOptions.AggressiveInlining)]
466 public static bool4x4 operator == (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
467
468 /// <summary>Returns the result of a componentwise equality operation on a float4x4 matrix and a float value.</summary>
469 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise equality.</param>
470 /// <param name="rhs">Right hand side float to use to compute componentwise equality.</param>
471 /// <returns>bool4x4 result of the componentwise equality.</returns>
472 [MethodImpl(MethodImplOptions.AggressiveInlining)]
473 public static bool4x4 operator == (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
474
475 /// <summary>Returns the result of a componentwise equality operation on a float value and a float4x4 matrix.</summary>
476 /// <param name="lhs">Left hand side float to use to compute componentwise equality.</param>
477 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise equality.</param>
478 /// <returns>bool4x4 result of the componentwise equality.</returns>
479 [MethodImpl(MethodImplOptions.AggressiveInlining)]
480 public static bool4x4 operator == (float lhs, float4x4 rhs) { return new bool4x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
481
482
483 /// <summary>Returns the result of a componentwise not equal operation on two float4x4 matrices.</summary>
484 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise not equal.</param>
485 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise not equal.</param>
486 /// <returns>bool4x4 result of the componentwise not equal.</returns>
487 [MethodImpl(MethodImplOptions.AggressiveInlining)]
488 public static bool4x4 operator != (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
489
490 /// <summary>Returns the result of a componentwise not equal operation on a float4x4 matrix and a float value.</summary>
491 /// <param name="lhs">Left hand side float4x4 to use to compute componentwise not equal.</param>
492 /// <param name="rhs">Right hand side float to use to compute componentwise not equal.</param>
493 /// <returns>bool4x4 result of the componentwise not equal.</returns>
494 [MethodImpl(MethodImplOptions.AggressiveInlining)]
495 public static bool4x4 operator != (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
496
497 /// <summary>Returns the result of a componentwise not equal operation on a float value and a float4x4 matrix.</summary>
498 /// <param name="lhs">Left hand side float to use to compute componentwise not equal.</param>
499 /// <param name="rhs">Right hand side float4x4 to use to compute componentwise not equal.</param>
500 /// <returns>bool4x4 result of the componentwise not equal.</returns>
501 [MethodImpl(MethodImplOptions.AggressiveInlining)]
502 public static bool4x4 operator != (float lhs, float4x4 rhs) { return new bool4x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
503
504
505
506 /// <summary>Returns the float4 element at a specified index.</summary>
507 unsafe public ref float4 this[int index]
508 {
509 get
510 {
511#if ENABLE_UNITY_COLLECTIONS_CHECKS
512 if ((uint)index >= 4)
513 throw new System.ArgumentException("index must be between[0...3]");
514#endif
515 fixed (float4x4* array = &this) { return ref ((float4*)array)[index]; }
516 }
517 }
518
519 /// <summary>Returns true if the float4x4 is equal to a given float4x4, false otherwise.</summary>
520 /// <param name="rhs">Right hand side argument to compare equality with.</param>
521 /// <returns>The result of the equality comparison.</returns>
522 [MethodImpl(MethodImplOptions.AggressiveInlining)]
523 public bool Equals(float4x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
524
525 /// <summary>Returns true if the float4x4 is equal to a given float4x4, false otherwise.</summary>
526 /// <param name="o">Right hand side argument to compare equality with.</param>
527 /// <returns>The result of the equality comparison.</returns>
528 public override bool Equals(object o) { return o is float4x4 converted && Equals(converted); }
529
530
531 /// <summary>Returns a hash code for the float4x4.</summary>
532 /// <returns>The computed hash code.</returns>
533 [MethodImpl(MethodImplOptions.AggressiveInlining)]
534 public override int GetHashCode() { return (int)math.hash(this); }
535
536
537 /// <summary>Returns a string representation of the float4x4.</summary>
538 /// <returns>String representation of the value.</returns>
539 [MethodImpl(MethodImplOptions.AggressiveInlining)]
540 public override string ToString()
541 {
542 return string.Format("float4x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f, {9}f, {10}f, {11}f, {12}f, {13}f, {14}f, {15}f)", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z, c0.w, c1.w, c2.w, c3.w);
543 }
544
545 /// <summary>Returns a string representation of the float4x4 using a specified format and culture-specific format information.</summary>
546 /// <param name="format">Format string to use during string formatting.</param>
547 /// <param name="formatProvider">Format provider to use during string formatting.</param>
548 /// <returns>String representation of the value.</returns>
549 [MethodImpl(MethodImplOptions.AggressiveInlining)]
550 public string ToString(string format, IFormatProvider formatProvider)
551 {
552 return string.Format("float4x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f, {9}f, {10}f, {11}f, {12}f, {13}f, {14}f, {15}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider), c3.w.ToString(format, formatProvider));
553 }
554
555 }
556
557 public static partial class math
558 {
559 /// <summary>Returns a float4x4 matrix constructed from four float4 vectors.</summary>
560 /// <param name="c0">The matrix column c0 will be set to this value.</param>
561 /// <param name="c1">The matrix column c1 will be set to this value.</param>
562 /// <param name="c2">The matrix column c2 will be set to this value.</param>
563 /// <param name="c3">The matrix column c3 will be set to this value.</param>
564 /// <returns>float4x4 constructed from arguments.</returns>
565 [MethodImpl(MethodImplOptions.AggressiveInlining)]
566 public static float4x4 float4x4(float4 c0, float4 c1, float4 c2, float4 c3) { return new float4x4(c0, c1, c2, c3); }
567
568 /// <summary>Returns a float4x4 matrix constructed from from 16 float values given in row-major order.</summary>
569 /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
570 /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
571 /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
572 /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
573 /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
574 /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
575 /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
576 /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
577 /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
578 /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
579 /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
580 /// <param name="m23">The matrix at row 2, column 3 will be set to this value.</param>
581 /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
582 /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
583 /// <param name="m32">The matrix at row 3, column 2 will be set to this value.</param>
584 /// <param name="m33">The matrix at row 3, column 3 will be set to this value.</param>
585 /// <returns>float4x4 constructed from arguments.</returns>
586 [MethodImpl(MethodImplOptions.AggressiveInlining)]
587 public static float4x4 float4x4(float m00, float m01, float m02, float m03,
588 float m10, float m11, float m12, float m13,
589 float m20, float m21, float m22, float m23,
590 float m30, float m31, float m32, float m33)
591 {
592 return new float4x4(m00, m01, m02, m03,
593 m10, m11, m12, m13,
594 m20, m21, m22, m23,
595 m30, m31, m32, m33);
596 }
597
598 /// <summary>Returns a float4x4 matrix constructed from a single float value by assigning it to every component.</summary>
599 /// <param name="v">float to convert to float4x4</param>
600 /// <returns>Converted value.</returns>
601 [MethodImpl(MethodImplOptions.AggressiveInlining)]
602 public static float4x4 float4x4(float v) { return new float4x4(v); }
603
604 /// <summary>Returns a float4x4 matrix constructed from a single bool value by converting it to float and assigning it to every component.</summary>
605 /// <param name="v">bool to convert to float4x4</param>
606 /// <returns>Converted value.</returns>
607 [MethodImpl(MethodImplOptions.AggressiveInlining)]
608 public static float4x4 float4x4(bool v) { return new float4x4(v); }
609
610 /// <summary>Return a float4x4 matrix constructed from a bool4x4 matrix by componentwise conversion.</summary>
611 /// <param name="v">bool4x4 to convert to float4x4</param>
612 /// <returns>Converted value.</returns>
613 [MethodImpl(MethodImplOptions.AggressiveInlining)]
614 public static float4x4 float4x4(bool4x4 v) { return new float4x4(v); }
615
616 /// <summary>Returns a float4x4 matrix constructed from a single int value by converting it to float and assigning it to every component.</summary>
617 /// <param name="v">int to convert to float4x4</param>
618 /// <returns>Converted value.</returns>
619 [MethodImpl(MethodImplOptions.AggressiveInlining)]
620 public static float4x4 float4x4(int v) { return new float4x4(v); }
621
622 /// <summary>Return a float4x4 matrix constructed from a int4x4 matrix by componentwise conversion.</summary>
623 /// <param name="v">int4x4 to convert to float4x4</param>
624 /// <returns>Converted value.</returns>
625 [MethodImpl(MethodImplOptions.AggressiveInlining)]
626 public static float4x4 float4x4(int4x4 v) { return new float4x4(v); }
627
628 /// <summary>Returns a float4x4 matrix constructed from a single uint value by converting it to float and assigning it to every component.</summary>
629 /// <param name="v">uint to convert to float4x4</param>
630 /// <returns>Converted value.</returns>
631 [MethodImpl(MethodImplOptions.AggressiveInlining)]
632 public static float4x4 float4x4(uint v) { return new float4x4(v); }
633
634 /// <summary>Return a float4x4 matrix constructed from a uint4x4 matrix by componentwise conversion.</summary>
635 /// <param name="v">uint4x4 to convert to float4x4</param>
636 /// <returns>Converted value.</returns>
637 [MethodImpl(MethodImplOptions.AggressiveInlining)]
638 public static float4x4 float4x4(uint4x4 v) { return new float4x4(v); }
639
640 /// <summary>Returns a float4x4 matrix constructed from a single double value by converting it to float and assigning it to every component.</summary>
641 /// <param name="v">double to convert to float4x4</param>
642 /// <returns>Converted value.</returns>
643 [MethodImpl(MethodImplOptions.AggressiveInlining)]
644 public static float4x4 float4x4(double v) { return new float4x4(v); }
645
646 /// <summary>Return a float4x4 matrix constructed from a double4x4 matrix by componentwise conversion.</summary>
647 /// <param name="v">double4x4 to convert to float4x4</param>
648 /// <returns>Converted value.</returns>
649 [MethodImpl(MethodImplOptions.AggressiveInlining)]
650 public static float4x4 float4x4(double4x4 v) { return new float4x4(v); }
651
652 /// <summary>Return the result of rotating a float3 vector by a float4x4 matrix</summary>
653 /// <param name ="a">Left hand side matrix argument that specifies the rotation.</param>
654 /// <param name ="b">Right hand side vector argument to be rotated.</param>
655 /// <returns>The rotated vector.</returns>
656 [MethodImpl(MethodImplOptions.AggressiveInlining)]
657 public static float3 rotate(float4x4 a, float3 b)
658 {
659 return (a.c0 * b.x + a.c1 * b.y + a.c2 * b.z).xyz;
660 }
661
662 /// <summary>Return the result of transforming a float3 point by a float4x4 matrix</summary>
663 /// <param name ="a">Left hand side matrix argument that specifies the transformation.</param>
664 /// <param name ="b">Right hand side point argument to be transformed.</param>
665 /// <returns>The transformed point.</returns>
666 [MethodImpl(MethodImplOptions.AggressiveInlining)]
667 public static float3 transform(float4x4 a, float3 b)
668 {
669 return (a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3).xyz;
670 }
671
672 /// <summary>Return the float4x4 transpose of a float4x4 matrix.</summary>
673 /// <param name="v">Value to transpose.</param>
674 /// <returns>Transposed value.</returns>
675 [MethodImpl(MethodImplOptions.AggressiveInlining)]
676 public static float4x4 transpose(float4x4 v)
677 {
678 return float4x4(
679 v.c0.x, v.c0.y, v.c0.z, v.c0.w,
680 v.c1.x, v.c1.y, v.c1.z, v.c1.w,
681 v.c2.x, v.c2.y, v.c2.z, v.c2.w,
682 v.c3.x, v.c3.y, v.c3.z, v.c3.w);
683 }
684
685 /// <summary>Returns the float4x4 full inverse of a float4x4 matrix.</summary>
686 /// <param name="m">Matrix to invert.</param>
687 /// <returns>The inverted matrix.</returns>
688 public static float4x4 inverse(float4x4 m)
689 {
690 float4 c0 = m.c0;
691 float4 c1 = m.c1;
692 float4 c2 = m.c2;
693 float4 c3 = m.c3;
694
695 float4 r0y_r1y_r0x_r1x = movelh(c1, c0);
696 float4 r0z_r1z_r0w_r1w = movelh(c2, c3);
697 float4 r2y_r3y_r2x_r3x = movehl(c0, c1);
698 float4 r2z_r3z_r2w_r3w = movehl(c3, c2);
699
700 float4 r1y_r2y_r1x_r2x = shuffle(c1, c0, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightZ);
701 float4 r1z_r2z_r1w_r2w = shuffle(c2, c3, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightZ);
702 float4 r3y_r0y_r3x_r0x = shuffle(c1, c0, ShuffleComponent.LeftW, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightX);
703 float4 r3z_r0z_r3w_r0w = shuffle(c2, c3, ShuffleComponent.LeftW, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightX);
704
705 float4 r0_wzyx = shuffle(r0z_r1z_r0w_r1w, r0y_r1y_r0x_r1x, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
706 float4 r1_wzyx = shuffle(r0z_r1z_r0w_r1w, r0y_r1y_r0x_r1x, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightW);
707 float4 r2_wzyx = shuffle(r2z_r3z_r2w_r3w, r2y_r3y_r2x_r3x, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
708 float4 r3_wzyx = shuffle(r2z_r3z_r2w_r3w, r2y_r3y_r2x_r3x, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightW);
709 float4 r0_xyzw = shuffle(r0y_r1y_r0x_r1x, r0z_r1z_r0w_r1w, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
710
711 // Calculate remaining inner term pairs. inner terms have zw=-xy, so we only have to calculate xy and can pack two pairs per vector.
712 float4 inner12_23 = r1y_r2y_r1x_r2x * r2z_r3z_r2w_r3w - r1z_r2z_r1w_r2w * r2y_r3y_r2x_r3x;
713 float4 inner02_13 = r0y_r1y_r0x_r1x * r2z_r3z_r2w_r3w - r0z_r1z_r0w_r1w * r2y_r3y_r2x_r3x;
714 float4 inner30_01 = r3z_r0z_r3w_r0w * r0y_r1y_r0x_r1x - r3y_r0y_r3x_r0x * r0z_r1z_r0w_r1w;
715
716 // Expand inner terms back to 4 components. zw signs still need to be flipped
717 float4 inner12 = shuffle(inner12_23, inner12_23, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
718 float4 inner23 = shuffle(inner12_23, inner12_23, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
719
720 float4 inner02 = shuffle(inner02_13, inner02_13, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
721 float4 inner13 = shuffle(inner02_13, inner02_13, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
722
723 // Calculate minors
724 float4 minors0 = r3_wzyx * inner12 - r2_wzyx * inner13 + r1_wzyx * inner23;
725
726 float4 denom = r0_xyzw * minors0;
727
728 // Horizontal sum of denominator. Free sign flip of z and w compensates for missing flip in inner terms.
729 denom = denom + shuffle(denom, denom, ShuffleComponent.LeftY, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightZ); // x+y x+y z+w z+w
730 denom = denom - shuffle(denom, denom, ShuffleComponent.LeftZ, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.RightX); // x+y-z-w x+y-z-w z+w-x-y z+w-x-y
731
732 float4 rcp_denom_ppnn = float4(1.0f) / denom;
733 float4x4 res;
734 res.c0 = minors0 * rcp_denom_ppnn;
735
736 float4 inner30 = shuffle(inner30_01, inner30_01, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
737 float4 inner01 = shuffle(inner30_01, inner30_01, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
738
739 float4 minors1 = r2_wzyx * inner30 - r0_wzyx * inner23 - r3_wzyx * inner02;
740 res.c1 = minors1 * rcp_denom_ppnn;
741
742 float4 minors2 = r0_wzyx * inner13 - r1_wzyx * inner30 - r3_wzyx * inner01;
743 res.c2 = minors2 * rcp_denom_ppnn;
744
745 float4 minors3 = r1_wzyx * inner02 - r0_wzyx * inner12 + r2_wzyx * inner01;
746 res.c3 = minors3 * rcp_denom_ppnn;
747 return res;
748 }
749
750 /// <summary>Fast matrix inverse for rigid transforms (orthonormal basis and translation)</summary>
751 /// <param name="m">Matrix to invert.</param>
752 /// <returns>The inverted matrix.</returns>
753 public static float4x4 fastinverse(float4x4 m)
754 {
755 float4 c0 = m.c0;
756 float4 c1 = m.c1;
757 float4 c2 = m.c2;
758 float4 pos = m.c3;
759
760 float4 zero = float4(0);
761
762 float4 t0 = unpacklo(c0, c2);
763 float4 t1 = unpacklo(c1, zero);
764 float4 t2 = unpackhi(c0, c2);
765 float4 t3 = unpackhi(c1, zero);
766
767 float4 r0 = unpacklo(t0, t1);
768 float4 r1 = unpackhi(t0, t1);
769 float4 r2 = unpacklo(t2, t3);
770
771 pos = -(r0 * pos.x + r1 * pos.y + r2 * pos.z);
772 pos.w = 1.0f;
773
774 return float4x4(r0, r1, r2, pos);
775 }
776
777 /// <summary>Returns the determinant of a float4x4 matrix.</summary>
778 /// <param name="m">Matrix to use when computing determinant.</param>
779 /// <returns>The determinant of the matrix.</returns>
780 public static float determinant(float4x4 m)
781 {
782 float4 c0 = m.c0;
783 float4 c1 = m.c1;
784 float4 c2 = m.c2;
785 float4 c3 = m.c3;
786
787 float m00 = c1.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c1.z * c3.w - c1.w * c3.z) + c3.y * (c1.z * c2.w - c1.w * c2.z);
788 float m01 = c0.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c0.z * c3.w - c0.w * c3.z) + c3.y * (c0.z * c2.w - c0.w * c2.z);
789 float m02 = c0.y * (c1.z * c3.w - c1.w * c3.z) - c1.y * (c0.z * c3.w - c0.w * c3.z) + c3.y * (c0.z * c1.w - c0.w * c1.z);
790 float m03 = c0.y * (c1.z * c2.w - c1.w * c2.z) - c1.y * (c0.z * c2.w - c0.w * c2.z) + c2.y * (c0.z * c1.w - c0.w * c1.z);
791
792 return c0.x * m00 - c1.x * m01 + c2.x * m02 - c3.x * m03;
793 }
794
795 /// <summary>Returns a uint hash code of a float4x4 matrix.</summary>
796 /// <param name="v">Matrix value to hash.</param>
797 /// <returns>uint hash of the argument.</returns>
798 [MethodImpl(MethodImplOptions.AggressiveInlining)]
799 public static uint hash(float4x4 v)
800 {
801 return csum(asuint(v.c0) * uint4(0xC4B1493Fu, 0xBA0966D3u, 0xAFBEE253u, 0x5B419C01u) +
802 asuint(v.c1) * uint4(0x515D90F5u, 0xEC9F68F3u, 0xF9EA92D5u, 0xC2FAFCB9u) +
803 asuint(v.c2) * uint4(0x616E9CA1u, 0xC5C5394Bu, 0xCAE78587u, 0x7A1541C9u) +
804 asuint(v.c3) * uint4(0xF83BD927u, 0x6A243BCBu, 0x509B84C9u, 0x91D13847u)) + 0x52F7230Fu;
805 }
806
807 /// <summary>
808 /// Returns a uint4 vector hash code of a float4x4 matrix.
809 /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
810 /// that are only reduced to a narrow uint hash at the very end instead of at every step.
811 /// </summary>
812 /// <param name="v">Matrix value to hash.</param>
813 /// <returns>uint4 hash of the argument.</returns>
814 [MethodImpl(MethodImplOptions.AggressiveInlining)]
815 public static uint4 hashwide(float4x4 v)
816 {
817 return (asuint(v.c0) * uint4(0xCF286E83u, 0xE121E6ADu, 0xC9CA1249u, 0x69B60C81u) +
818 asuint(v.c1) * uint4(0xE0EB6C25u, 0xF648BEABu, 0x6BDB2B07u, 0xEF63C699u) +
819 asuint(v.c2) * uint4(0x9001903Fu, 0xA895B9CDu, 0x9D23B201u, 0x4B01D3E1u) +
820 asuint(v.c3) * uint4(0x7461CA0Du, 0x79725379u, 0xD6258E5Bu, 0xEE390C97u)) + 0x9C8A2F05u;
821 }
822
823 }
824}