1 /*
2 Copyright (C) 2016 Felipe Ferreira da Silva
3
4 This software is provided 'as-is', without any express or implied warranty. In
5 no event will the authors be held liable for any damages arising from the use of
6 this software.
7
8 Permission is granted to anyone to use this software for any purpose, including
9 commercial applications, and to alter it and redistribute it freely, subject to
10 the following restrictions:
11
12 1. The origin of this software must not be misrepresented; you must not claim
13 that you wrote the original software. If you use this software in a
14 product, an acknowledgment in the product documentation would be
15 appreciated but is not required.
16 2. Altered source versions must be plainly marked as such, and must not be
17 misrepresented as being the original software.
18 3. This notice may not be removed or altered from any source distribution.
19 */
20
21 #ifndef MATHC_H
22 #define MATHC_H
23
24 #include <math.h>
25 #include <float.h>
26 #ifdef MATHC_NO_STDBOOL
27 #define bool int
28 #define true 1
29 #define false 0
30 #else
31 #include <stdbool.h>
32 #endif
33 #ifndef MATHC_NO_STDINT
34 #include <stdint.h>
35 #endif
36
37 #define MATHC_MAJOR_VERSION 2
38 #define MATHC_MINOR_VERSION 0
39 #define MATHC_PATCH_VERSION 0
40
41 /* Component type */
42 #ifndef mfloat_t
43 #define mfloat_t float
44 #endif
45 #ifndef mint_t
46 #ifndef MATHC_NO_STDINT
47 #define mint_t int32_t
48 #else
49 #define mint_t int
50 #endif
51 #endif
52
53 /* Array sizes for declarations */
54 #define VEC2_SIZE 2
55 #define VEC3_SIZE 3
56 #define VEC4_SIZE 4
57 #define QUAT_SIZE 4
58 #define MAT2_SIZE 4
59 #define MAT3_SIZE 9
60 #define MAT4_SIZE 16
61
62 /* Float-point precision used internally */
63 #ifdef MATHC_DOUBLE_PRECISION
64 #define MPI 3.14159265358979323846
65 #define MPI_2 1.57079632679489661923
66 #define MPI_4 0.78539816339744830962
67 #define MFLT_EPSILON DBL_EPSILON
68 #define MABS fabs
69 #define MMIN fmin
70 #define MMAX fmax
71 #define MSQRT sqrt
72 #define MSIN sin
73 #define MCOS cos
74 #define MACOS acos
75 #define MTAN tan
76 #define MATAN2 atan2
77 #define MPOW pow
78 #define MFLOOR floor
79 #define MCEIL ceil
80 #define MROUND round
81 #define MFLOAT_C(c) c
82 #else
83 #define MPI 3.1415926536f
84 #define MPI_2 1.5707963268f
85 #define MPI_4 0.7853981634f
86 #define MFLT_EPSILON FLT_EPSILON
87 #define MABS fabsf
88 #define MMIN fminf
89 #define MMAX fmaxf
90 #define MSQRT sqrtf
91 #define MSIN sinf
92 #define MCOS cosf
93 #define MACOS acosf
94 #define MTAN tanf
95 #define MATAN2 atan2f
96 #define MPOW powf
97 #define MFLOOR floorf
98 #define MCEIL ceilf
99 #define MROUND roundf
100 #define MFLOAT_C(c) c ## f
101 #endif
102 #define MMAXI(x, y) ((x) > (y) ? (x) : (y))
103 #define MMINI(x, y) ((x) < (y) ? (x) : (y))
104
105 /* Enable or disable structures */
106 #ifdef MATHC_NO_STRUCTURES
107 #define MATHC_NO_POINTER_STRUCT_FUNCTIONS
108 #define MATHC_NO_STRUCT_FUNCTIONS
109 #else
110 struct vec2 {
111 mfloat_t x;
112 mfloat_t y;
113 };
114
115 struct vec3 {
116 mfloat_t x;
117 mfloat_t y;
118 mfloat_t z;
119 };
120
121 struct vec4 {
122 mint_t x;
123 mint_t y;
124 mint_t z;
125 mint_t w;
126 };
127
128 struct vec2i {
129 mint_t x;
130 mint_t y;
131 };
132
133 struct vec3i {
134 mint_t x;
135 mint_t y;
136 mint_t z;
137 };
138
139 struct vec4i {
140 mint_t x;
141 mint_t y;
142 mint_t z;
143 mint_t w;
144 };
145
146 struct quat {
147 mfloat_t x;
148 mfloat_t y;
149 mfloat_t z;
150 mfloat_t w;
151 };
152
153 /*
154 Matrix 2x2 representation:
155 0/m11 2/m12
156 1/m21 3/m22
157 */
158 struct mat2 {
159 mfloat_t m11;
160 mfloat_t m21;
161 mfloat_t m12;
162 mfloat_t m22;
163 };
164
165 /*
166 Matrix 3x3 representation:
167 0/m11 3/m12 6/m13
168 1/m21 4/m22 7/m23
169 2/m31 5/m32 8/m33
170 */
171 struct mat3 {
172 mfloat_t m11;
173 mfloat_t m21;
174 mfloat_t m31;
175 mfloat_t m12;
176 mfloat_t m22;
177 mfloat_t m32;
178 mfloat_t m13;
179 mfloat_t m23;
180 mfloat_t m33;
181 };
182
183 /*
184 Matrix 4x4 representation:
185 0/m11 4/m12 8/m13 12/m14
186 1/m21 5/m22 9/m23 13/m24
187 2/m31 6/m32 10/m33 14/m34
188 3/m41 7/m42 11/m43 15/m44
189 */
190 struct mat4 {
191 mfloat_t m11;
192 mfloat_t m21;
193 mfloat_t m31;
194 mfloat_t m41;
195 mfloat_t m12;
196 mfloat_t m22;
197 mfloat_t m32;
198 mfloat_t m42;
199 mfloat_t m13;
200 mfloat_t m23;
201 mfloat_t m33;
202 mfloat_t m43;
203 mfloat_t m14;
204 mfloat_t m24;
205 mfloat_t m34;
206 mfloat_t m44;
207 };
208 #endif
209
210 #if !defined(MATHC_NO_POINTER_STRUCT_FUNCTIONS) || !defined(MATHC_NO_STRUCT_FUNCTIONS)
211 #ifdef _MSC_VER
212 #define MATHC_INLINE __forceinline
213 #else
214 #define MATHC_INLINE inline __attribute__((always_inline))
215 #endif
216 #endif
217
218 /* Utils */
219 bool nearly_equal(mfloat_t a, mfloat_t b, mfloat_t epsilon);
220 mfloat_t to_radians(mfloat_t degrees);
221 mfloat_t to_degrees(mfloat_t radians);
222
223 /* Vector 2D */
224 bool vec2_is_zero(mfloat_t *a);
225 bool vec2_is_near_zero(mfloat_t *a, mfloat_t epsilon);
226 bool vec2_is_equal(mfloat_t *a, mfloat_t *b);
227 bool vec2_is_nearly_equal(mfloat_t *a, mfloat_t *b, mfloat_t epsilon);
228 mfloat_t *vec2(mfloat_t *result, mfloat_t x, mfloat_t y);
229 mfloat_t *vec2_assign(mfloat_t *result, mfloat_t *a);
230 mfloat_t *vec2_assign_vec2i(mfloat_t *result, mint_t *a);
231 mfloat_t *vec2_zero(mfloat_t *result);
232 mfloat_t *vec2_one(mfloat_t *result);
233 mfloat_t *vec2_add(mfloat_t *result, mfloat_t *a, mfloat_t *b);
234 mfloat_t *vec2_subtract(mfloat_t *result, mfloat_t *a, mfloat_t *b);
235 mfloat_t *vec2_scale(mfloat_t *result, mfloat_t *a, mfloat_t scalar);
236 mfloat_t *vec2_multiply(mfloat_t *result, mfloat_t *a, mfloat_t *b);
237 mfloat_t *vec2_multiply_mat2(mfloat_t *result, mfloat_t *a, mfloat_t *m);
238 mfloat_t *vec2_divide(mfloat_t *result, mfloat_t *a, mfloat_t *b);
239 mfloat_t *vec2_snap(mfloat_t *result, mfloat_t *a, mfloat_t *b);
240 mfloat_t *vec2_negative(mfloat_t *result, mfloat_t *a);
241 mfloat_t *vec2_inverse(mfloat_t *result, mfloat_t *a);
242 mfloat_t *vec2_abs(mfloat_t *result, mfloat_t *a);
243 mfloat_t *vec2_floor(mfloat_t *result, mfloat_t *a);
244 mfloat_t *vec2_ceil(mfloat_t *result, mfloat_t *a);
245 mfloat_t *vec2_round(mfloat_t *result, mfloat_t *a);
246 mfloat_t *vec2_max(mfloat_t *result, mfloat_t *a, mfloat_t *b);
247 mfloat_t *vec2_min(mfloat_t *result, mfloat_t *a, mfloat_t *b);
248 mfloat_t *vec2_clamp(mfloat_t *result, mfloat_t *a, mfloat_t *lower, mfloat_t *higher);
249 mfloat_t *vec2_normalize(mfloat_t *result, mfloat_t *a);
250 mfloat_t *vec2_project(mfloat_t *result, mfloat_t *a, mfloat_t *b);
251 mfloat_t *vec2_slide(mfloat_t *result, mfloat_t *a, mfloat_t *b);
252 mfloat_t *vec2_reflect(mfloat_t *result, mfloat_t *a, mfloat_t *b);
253 mfloat_t *vec2_tangent(mfloat_t *result, mfloat_t *a);
254 mfloat_t *vec2_rotate(mfloat_t *result, mfloat_t *a, mfloat_t angle);
255 mfloat_t *vec2_lerp(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t p);
256 mfloat_t *vec2_bezier3(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t *c, mfloat_t p);
257 mfloat_t *vec2_bezier4(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t *c, mfloat_t *d, mfloat_t p);
258 mfloat_t vec2_dot(mfloat_t *a, mfloat_t *b);
259 mfloat_t vec2_angle(mfloat_t *a);
260 mfloat_t vec2_length(mfloat_t *a);
261 mfloat_t vec2_length_squared(mfloat_t *a);
262 mfloat_t vec2_distance(mfloat_t *a, mfloat_t *b);
263 mfloat_t vec2_distance_squared(mfloat_t *a, mfloat_t *b);
264
265 /* Vector 2D Integer */
266 bool vec2i_is_zero(mint_t *a);
267 bool vec2i_is_equal(mint_t *a, mint_t *b);
268 mint_t *vec2i(mint_t *result, mint_t x, mint_t y);
269 mint_t *vec2i_assign(mint_t *result, mint_t *a);
270 mint_t *vec2i_assign_vec2(mint_t *result, mfloat_t *a);
271 mint_t *vec2i_zero(mint_t *result);
272 mint_t *vec2i_one(mint_t *result);
273 mint_t *vec2i_add(mint_t *result, mint_t *a, mint_t *b);
274 mint_t *vec2i_subtract(mint_t *result, mint_t *a, mint_t *b);
275 mint_t *vec2i_scale(mint_t *result, mint_t *a, mfloat_t scalar);
276 mint_t *vec2i_multiply(mint_t *result, mint_t *a, mint_t *b);
277 mint_t *vec2i_multiply_mat2(mint_t *result, mint_t *a, mfloat_t *m);
278 mint_t *vec2i_divide(mint_t *result, mint_t *a, mint_t *b);
279 mint_t *vec2i_snap(mint_t *result, mint_t *a, mint_t *b);
280 mint_t *vec2i_negative(mint_t *result, mint_t *a);
281 mint_t *vec2i_inverse(mint_t *result, mint_t *a);
282 mint_t *vec2i_abs(mint_t *result, mint_t *a);
283 mint_t *vec2i_floor(mint_t *result, mfloat_t *a);
284 mint_t *vec2i_ceil(mint_t *result, mfloat_t *a);
285 mint_t *vec2i_round(mint_t *result, mfloat_t *a);
286 mint_t *vec2i_max(mint_t *result, mint_t *a, mint_t *b);
287 mint_t *vec2i_min(mint_t *result, mint_t *a, mint_t *b);
288 mint_t *vec2i_clamp(mint_t *result, mint_t *a, mint_t *lower, mint_t *higher);
289 mint_t *vec2i_normalize(mint_t *result, mint_t *a);
290 mint_t *vec2i_project(mint_t *result, mint_t *a, mint_t *b);
291 mint_t *vec2i_slide(mint_t *result, mint_t *a, mint_t *b);
292 mint_t *vec2i_reflect(mint_t *result, mint_t *a, mint_t *b);
293 mint_t *vec2i_tangent(mint_t *result, mint_t *a);
294 mint_t *vec2i_rotate(mint_t *result, mint_t *a, mfloat_t angle);
295 mint_t *vec2i_lerp(mint_t *result, mint_t *a, mint_t *b, mfloat_t p);
296 mint_t *vec2i_bezier3(mint_t *result, mint_t *a, mint_t *b, mint_t *c, mfloat_t p);
297 mint_t *vec2i_bezier4(mint_t *result, mint_t *a, mint_t *b, mint_t *c, mint_t *d, mfloat_t p);
298 mint_t vec2i_dot(mint_t *a, mint_t *b);
299 mfloat_t vec2i_angle(mint_t *a);
300 mfloat_t vec2i_length(mint_t *a);
301 mint_t vec2i_length_squared(mint_t *a);
302 mfloat_t vec2i_distance(mint_t *a, mint_t *b);
303 mint_t vec2i_distance_squared(mint_t *a, mint_t *b);
304
305 /* Vector 3D */
306 bool vec3_is_zero(mfloat_t *a);
307 bool vec3_is_near_zero(mfloat_t *a, mfloat_t epsilon);
308 bool vec3_is_equal(mfloat_t *a, mfloat_t *b);
309 bool vec3_is_nearly_equal(mfloat_t *a, mfloat_t *b, mfloat_t epsilon);
310 mfloat_t *vec3(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z);
311 mfloat_t *vec3_assign(mfloat_t *result, mfloat_t *a);
312 mfloat_t *vec3_assign_vec3i(mfloat_t *result, mint_t *a);
313 mfloat_t *vec3_zero(mfloat_t *result);
314 mfloat_t *vec3_one(mfloat_t *result);
315 mfloat_t *vec3_add(mfloat_t *result, mfloat_t *a, mfloat_t *b);
316 mfloat_t *vec3_subtract(mfloat_t *result, mfloat_t *a, mfloat_t *b);
317 mfloat_t *vec3_scale(mfloat_t *result, mfloat_t *a, mfloat_t scalar);
318 mfloat_t *vec3_multiply(mfloat_t *result, mfloat_t *a, mfloat_t *b);
319 mfloat_t *vec3_multiply_mat3(mfloat_t *result, mfloat_t *a, mfloat_t *m);
320 mfloat_t *vec3_divide(mfloat_t *result, mfloat_t *a, mfloat_t *b);
321 mfloat_t *vec3_snap(mfloat_t *result, mfloat_t *a, mfloat_t *b);
322 mfloat_t *vec3_negative(mfloat_t *result, mfloat_t *a);
323 mfloat_t *vec3_inverse(mfloat_t *result, mfloat_t *a);
324 mfloat_t *vec3_abs(mfloat_t *result, mfloat_t *a);
325 mfloat_t *vec3_floor(mfloat_t *result, mfloat_t *a);
326 mfloat_t *vec3_ceil(mfloat_t *result, mfloat_t *a);
327 mfloat_t *vec3_round(mfloat_t *result, mfloat_t *a);
328 mfloat_t *vec3_max(mfloat_t *result, mfloat_t *a, mfloat_t *b);
329 mfloat_t *vec3_min(mfloat_t *result, mfloat_t *a, mfloat_t *b);
330 mfloat_t *vec3_clamp(mfloat_t *result, mfloat_t *a, mfloat_t *lower, mfloat_t *higher);
331 mfloat_t *vec3_cross(mfloat_t *result, mfloat_t *a, mfloat_t *b);
332 mfloat_t *vec3_normalize(mfloat_t *result, mfloat_t *a);
333 mfloat_t *vec3_project(mfloat_t *result, mfloat_t *a, mfloat_t *b);
334 mfloat_t *vec3_slide(mfloat_t *result, mfloat_t *a, mfloat_t *b);
335 mfloat_t *vec3_reflect(mfloat_t *result, mfloat_t *a, mfloat_t *b);
336 mfloat_t *vec3_lerp(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t p);
337 mfloat_t *vec3_bezier3(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t *c, mfloat_t p);
338 mfloat_t *vec3_bezier4(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t *c, mfloat_t *d, mfloat_t p);
339 mfloat_t vec3_dot(mfloat_t *a, mfloat_t *b);
340 mfloat_t vec3_length(mfloat_t *a);
341 mfloat_t vec3_length_squared(mfloat_t *a);
342 mfloat_t vec3_distance(mfloat_t *a, mfloat_t *b);
343 mfloat_t vec3_distance_squared(mfloat_t *a, mfloat_t *b);
344
345 /* Vector 3D Integer */
346 bool vec3i_is_zero(mint_t *a);
347 bool vec3i_is_equal(mint_t *a, mint_t *b);
348 mint_t *vec3i(mint_t *result, mint_t x, mint_t y, mint_t z);
349 mint_t *vec3i_assign(mint_t *result, mint_t *a);
350 mint_t *vec3i_assign_vec3(mint_t *result, mfloat_t *a);
351 mint_t *vec3i_zero(mint_t *result);
352 mint_t *vec3i_one(mint_t *result);
353 mint_t *vec3i_add(mint_t *result, mint_t *a, mint_t *b);
354 mint_t *vec3i_subtract(mint_t *result, mint_t *a, mint_t *b);
355 mint_t *vec3i_scale(mint_t *result, mint_t *a, mfloat_t scalar);
356 mint_t *vec3i_multiply(mint_t *result, mint_t *a, mint_t *b);
357 mint_t *vec3i_multiply_mat3(mint_t *result, mint_t *a, mfloat_t *m);
358 mint_t *vec3i_divide(mint_t *result, mint_t *a, mint_t *b);
359 mint_t *vec3i_snap(mint_t *result, mint_t *a, mint_t *b);
360 mint_t *vec3i_negative(mint_t *result, mint_t *a);
361 mint_t *vec3i_inverse(mint_t *result, mint_t *a);
362 mint_t *vec3i_abs(mint_t *result, mint_t *a);
363 mint_t *vec3i_floor(mint_t *result, mfloat_t *a);
364 mint_t *vec3i_ceil(mint_t *result, mfloat_t *a);
365 mint_t *vec3i_round(mint_t *result, mfloat_t *a);
366 mint_t *vec3i_max(mint_t *result, mint_t *a, mint_t *b);
367 mint_t *vec3i_min(mint_t *result, mint_t *a, mint_t *b);
368 mint_t *vec3i_clamp(mint_t *result, mint_t *a, mint_t *lower, mint_t *higher);
369 mint_t *vec3i_cross(mint_t *result, mint_t *a, mint_t *b);
370 mint_t *vec3i_normalize(mint_t *result, mint_t *a);
371 mint_t *vec3i_project(mint_t *result, mint_t *a, mint_t *b);
372 mint_t *vec3i_slide(mint_t *result, mint_t *a, mint_t *b);
373 mint_t *vec3i_reflect(mint_t *result, mint_t *a, mint_t *b);
374 mint_t *vec3i_lerp(mint_t *result, mint_t *a, mint_t *b, mfloat_t p);
375 mint_t *vec3i_bezier3(mint_t *result, mint_t *a, mint_t *b, mint_t *c, mfloat_t p);
376 mint_t *vec3i_bezier4(mint_t *result, mint_t *a, mint_t *b, mint_t *c, mint_t *d, mfloat_t p);
377 mint_t vec3i_dot(mint_t *a, mint_t *b);
378 mfloat_t vec3i_length(mint_t *a);
379 mint_t vec3i_length_squared(mint_t *a);
380 mfloat_t vec3i_distance(mint_t *a, mint_t *b);
381 mint_t vec3i_distance_squared(mint_t *a, mint_t *b);
382
383 /* Vector 4D */
384 bool vec4_is_zero(mfloat_t *a);
385 bool vec4_is_near_zero(mfloat_t *a, mfloat_t epsilon);
386 bool vec4_is_equal(mfloat_t *a, mfloat_t *b);
387 bool vec4_is_nearly_equal(mfloat_t *a, mfloat_t *b, mfloat_t epsilon);
388 mfloat_t *vec4(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
389 mfloat_t *vec4_assign(mfloat_t *result, mfloat_t *a);
390 mfloat_t *vec4_assign_vec4i(mfloat_t *result, mint_t *a);
391 mfloat_t *vec4_zero(mfloat_t *result);
392 mfloat_t *vec4_one(mfloat_t *result);
393 mfloat_t *vec4_add(mfloat_t *result, mfloat_t *a, mfloat_t *b);
394 mfloat_t *vec4_subtract(mfloat_t *result, mfloat_t *a, mfloat_t *b);
395 mfloat_t *vec4_scale(mfloat_t *result, mfloat_t *a, mfloat_t scalar);
396 mfloat_t *vec4_multiply(mfloat_t *result, mfloat_t *a, mfloat_t *b);
397 mfloat_t *vec4_multiply_mat4(mfloat_t *result, mfloat_t *a, mfloat_t *m);
398 mfloat_t *vec4_divide(mfloat_t *result, mfloat_t *a, mfloat_t *b);
399 mfloat_t *vec4_snap(mfloat_t *result, mfloat_t *a, mfloat_t *b);
400 mfloat_t *vec4_negative(mfloat_t *result, mfloat_t *a);
401 mfloat_t *vec4_inverse(mfloat_t *result, mfloat_t *a);
402 mfloat_t *vec4_abs(mfloat_t *result, mfloat_t *a);
403 mfloat_t *vec4_floor(mfloat_t *result, mfloat_t *a);
404 mfloat_t *vec4_ceil(mfloat_t *result, mfloat_t *a);
405 mfloat_t *vec4_round(mfloat_t *result, mfloat_t *a);
406 mfloat_t *vec4_max(mfloat_t *result, mfloat_t *a, mfloat_t *b);
407 mfloat_t *vec4_min(mfloat_t *result, mfloat_t *a, mfloat_t *b);
408 mfloat_t *vec4_clamp(mfloat_t *result, mfloat_t *a, mfloat_t *lower, mfloat_t *higher);
409 mfloat_t *vec4_normalize(mfloat_t *result, mfloat_t *a);
410 mfloat_t *vec4_lerp(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t p);
411
412 /* Vector 4D Integer */
413 bool vec4i_is_zero(mint_t *a);
414 bool vec4i_is_equal(mint_t *a, mint_t *b);
415 mint_t *vec4i(mint_t *result, mint_t x, mint_t y, mint_t z, mint_t w);
416 mint_t *vec4i_assign(mint_t *result, mint_t *a);
417 mint_t *vec4i_assign_vec4(mint_t *result, mfloat_t *a);
418 mint_t *vec4i_zero(mint_t *result);
419 mint_t *vec4i_one(mint_t *result);
420 mint_t *vec4i_add(mint_t *result, mint_t *a, mint_t *b);
421 mint_t *vec4i_subtract(mint_t *result, mint_t *a, mint_t *b);
422 mint_t *vec4i_scale(mint_t *result, mint_t *a, mfloat_t scalar);
423 mint_t *vec4i_multiply(mint_t *result, mint_t *a, mint_t *b);
424 mint_t *vec4i_multiply_mat4(mint_t *result, mint_t *a, mfloat_t *m);
425 mint_t *vec4i_divide(mint_t *result, mint_t *a, mint_t *b);
426 mint_t *vec4i_snap(mint_t *result, mint_t *a, mint_t *b);
427 mint_t *vec4i_negative(mint_t *result, mint_t *a);
428 mint_t *vec4i_inverse(mint_t *result, mint_t *a);
429 mint_t *vec4i_abs(mint_t *result, mint_t *a);
430 mint_t *vec4i_floor(mint_t *result, mfloat_t *a);
431 mint_t *vec4i_ceil(mint_t *result, mfloat_t *a);
432 mint_t *vec4i_round(mint_t *result, mfloat_t *a);
433 mint_t *vec4i_max(mint_t *result, mint_t *a, mint_t *b);
434 mint_t *vec4i_min(mint_t *result, mint_t *a, mint_t *b);
435 mint_t *vec4i_clamp(mint_t *result, mint_t *a, mint_t *lower, mint_t *higher);
436 mint_t *vec4i_normalize(mint_t *result, mint_t *a);
437 mint_t *vec4i_lerp(mint_t *result, mint_t *a, mint_t *b, mfloat_t p);
438
439 /* Quaternion */
440 bool quat_is_zero(mfloat_t *a);
441 bool quat_is_near_zero(mfloat_t *a, mfloat_t epsilon);
442 bool quat_is_equal(mfloat_t *a, mfloat_t *b);
443 bool quat_is_nearly_equal(mfloat_t *a, mfloat_t *b, mfloat_t epsilon);
444 mfloat_t *quat(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
445 mfloat_t *quat_assign(mfloat_t *result, mfloat_t *a);
446 mfloat_t *quat_zero(mfloat_t *result);
447 mfloat_t *quat_null(mfloat_t *result);
448 mfloat_t *quat_scale(mfloat_t *result, mfloat_t *a, mfloat_t scalar);
449 mfloat_t *quat_multiply(mfloat_t *result, mfloat_t *a, mfloat_t *b);
450 mfloat_t *quat_divide(mfloat_t *result, mfloat_t *a, mfloat_t *b);
451 mfloat_t *quat_negative(mfloat_t *result, mfloat_t *a);
452 mfloat_t *quat_conjugate(mfloat_t *result, mfloat_t *a);
453 mfloat_t *quat_inverse(mfloat_t *result, mfloat_t *a);
454 mfloat_t *quat_normalize(mfloat_t *result, mfloat_t *a);
455 mfloat_t *quat_power(mfloat_t *result, mfloat_t *a, mfloat_t exponent);
456 mfloat_t *quat_from_axis_angle(mfloat_t *result, mfloat_t *a, mfloat_t angle);
457 mfloat_t *quat_from_vec3(mfloat_t *result, mfloat_t *a, mfloat_t *b);
458 mfloat_t *quat_from_mat4(mfloat_t *result, mfloat_t *m);
459 mfloat_t *quat_from_yaw_pitch_roll(mfloat_t *result, mfloat_t yaw, mfloat_t pitch, mfloat_t roll);
460 mfloat_t *quat_lerp(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t p);
461 mfloat_t *quat_slerp(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t p);
462 mfloat_t quat_dot(mfloat_t *a, mfloat_t *b);
463 mfloat_t quat_angle(mfloat_t *a, mfloat_t *b);
464 mfloat_t quat_length(mfloat_t *a);
465 mfloat_t quat_length_squared(mfloat_t *a);
466
467 /* Matrix 2x2 */
468 mfloat_t *mat2(mfloat_t *result,
469 mfloat_t m11, mfloat_t m12,
470 mfloat_t m21, mfloat_t m22);
471 mfloat_t *mat2_zero(mfloat_t *result);
472 mfloat_t *mat2_identity(mfloat_t *result);
473 mfloat_t mat2_determinant(mfloat_t *m);
474 mfloat_t *mat2_assign(mfloat_t *result, mfloat_t *m);
475 mfloat_t *mat2_assign_mat3(mfloat_t *result, mfloat_t *m);
476 mfloat_t *mat2_assign_mat4(mfloat_t *result, mfloat_t *m);
477 mfloat_t *mat2_transpose(mfloat_t *result, mfloat_t *m);
478 mfloat_t *mat2_cofactor(mfloat_t *result, mfloat_t *m);
479 mfloat_t *mat2_inverse(mfloat_t *result, mfloat_t *m);
480 mfloat_t *mat2_rotation(mfloat_t *result, mfloat_t angle);
481 mfloat_t *mat2_scaling(mfloat_t *result, mfloat_t *v);
482 mfloat_t *mat2_negative(mfloat_t *result, mfloat_t *m);
483 mfloat_t *mat2_scale(mfloat_t *result, mfloat_t *m, mfloat_t scalar);
484 mfloat_t *mat2_multiply(mfloat_t *result, mfloat_t *a, mfloat_t *b);
485 mfloat_t *mat2_lerp(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t p);
486
487 /* Matrix 3x3 */
488 mfloat_t *mat3(mfloat_t *result,
489 mfloat_t m11, mfloat_t m12, mfloat_t m13,
490 mfloat_t m21, mfloat_t m22, mfloat_t m23,
491 mfloat_t m31, mfloat_t m32, mfloat_t m33);
492 mfloat_t *mat3_zero(mfloat_t *result);
493 mfloat_t *mat3_identity(mfloat_t *result);
494 mfloat_t mat3_determinant(mfloat_t *m);
495 mfloat_t *mat3_assign(mfloat_t *result, mfloat_t *m);
496 mfloat_t *mat3_assign_mat2(mfloat_t *result, mfloat_t *m);
497 mfloat_t *mat3_assign_mat4(mfloat_t *result, mfloat_t *m);
498 mfloat_t *mat3_transpose(mfloat_t *result, mfloat_t *m);
499 mfloat_t *mat3_cofactor(mfloat_t *result, mfloat_t *m);
500 mfloat_t *mat3_adjugate(mfloat_t *result, mfloat_t *m);
501 mfloat_t *mat3_inverse(mfloat_t *result, mfloat_t *m);
502 mfloat_t *mat3_rotation_x(mfloat_t *result, mfloat_t angle);
503 mfloat_t *mat3_rotation_y(mfloat_t *result, mfloat_t angle);
504 mfloat_t *mat3_rotation_z(mfloat_t *result, mfloat_t angle);
505 mfloat_t *mat3_rotation_axis(mfloat_t *result, mfloat_t *a, mfloat_t angle);
506 mfloat_t *mat3_rotation_quaternion(mfloat_t *result, mfloat_t *q);
507 mfloat_t *mat3_scaling(mfloat_t *result, mfloat_t *v);
508 mfloat_t *mat3_negative(mfloat_t *result, mfloat_t *m);
509 mfloat_t *mat3_scale(mfloat_t *result, mfloat_t *m, mfloat_t scalar);
510 mfloat_t *mat3_multiply(mfloat_t *result, mfloat_t *a, mfloat_t *b);
511 mfloat_t *mat3_lerp(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t p);
512
513 /* Matrix 4x4 */
514 mfloat_t *mat4(mfloat_t *result,
515 mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14,
516 mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24,
517 mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34,
518 mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44);
519 mfloat_t *mat4_zero(mfloat_t *result);
520 mfloat_t *mat4_identity(mfloat_t *result);
521 mfloat_t mat4_determinant(mfloat_t *m);
522 mfloat_t *mat4_assign(mfloat_t *result, mfloat_t *m);
523 mfloat_t *mat4_assign_mat2(mfloat_t *result, mfloat_t *m);
524 mfloat_t *mat4_assign_mat3(mfloat_t *result, mfloat_t *m);
525 mfloat_t *mat4_transpose(mfloat_t *result, mfloat_t *m);
526 mfloat_t *mat4_adjugate(mfloat_t *result, mfloat_t *m);
527 mfloat_t *mat4_inverse(mfloat_t *result, mfloat_t *m);
528 mfloat_t *mat4_ortho(mfloat_t *result, mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f);
529 mfloat_t *mat4_perspective(mfloat_t *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f);
530 mfloat_t *mat4_perspective_fov(mfloat_t *result, mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f);
531 mfloat_t *mat4_perspective_infinite(mfloat_t *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n);
532 mfloat_t *mat4_rotation_x(mfloat_t *result, mfloat_t angle);
533 mfloat_t *mat4_rotation_y(mfloat_t *result, mfloat_t angle);
534 mfloat_t *mat4_rotation_z(mfloat_t *result, mfloat_t angle);
535 mfloat_t *mat4_rotation_axis(mfloat_t *result, mfloat_t *a, mfloat_t angle);
536 mfloat_t *mat4_rotation_quaternion(mfloat_t *result, mfloat_t *q);
537 mfloat_t *mat4_look_at(mfloat_t *result, mfloat_t *position, mfloat_t *target, mfloat_t *up_axis);
538 mfloat_t *mat4_translation(mfloat_t *result, mfloat_t *v);
539 mfloat_t *mat4_scaling(mfloat_t *result, mfloat_t *v);
540 mfloat_t *mat4_negative(mfloat_t *result, mfloat_t *m);
541 mfloat_t *mat4_scale(mfloat_t *result, mfloat_t *m, mfloat_t s);
542 mfloat_t *mat4_multiply(mfloat_t *result, mfloat_t *a, mfloat_t *b);
543 mfloat_t *mat4_lerp(mfloat_t *result, mfloat_t *a, mfloat_t *b, mfloat_t p);
544
545 #ifndef MATHC_NO_POINTER_STRUCT_FUNCTIONS
546 /* Vector 2D */
psvec2_is_zero(struct vec2 * a)547 MATHC_INLINE bool psvec2_is_zero(struct vec2 *a)
548 {
549 return vec2_is_zero((mfloat_t *)a);
550 }
551
psvec2_is_near_zero(struct vec2 * a,mfloat_t epsilon)552 MATHC_INLINE bool psvec2_is_near_zero(struct vec2 *a, mfloat_t epsilon)
553 {
554 return vec2_is_near_zero((mfloat_t *)a, epsilon);
555 }
556
psvec2_is_equal(struct vec2 * a,struct vec2 * b)557 MATHC_INLINE bool psvec2_is_equal(struct vec2 *a, struct vec2 *b)
558 {
559 return vec2_is_equal((mfloat_t *)a, (mfloat_t *)b);
560 }
561
psvec2_is_nearly_equal(struct vec2 * a,struct vec2 * b,mfloat_t epsilon)562 MATHC_INLINE bool psvec2_is_nearly_equal(struct vec2 *a, struct vec2 *b, mfloat_t epsilon)
563 {
564 return vec2_is_nearly_equal((mfloat_t *)a, (mfloat_t *)b, epsilon);
565 }
566
psvec2(struct vec2 * result,mfloat_t x,mfloat_t y)567 MATHC_INLINE struct vec2 *psvec2(struct vec2 *result, mfloat_t x, mfloat_t y)
568 {
569 vec2((mfloat_t *)result, x, y);
570 return result;
571 }
572
psvec2_assign(struct vec2 * result,struct vec2 * a)573 MATHC_INLINE struct vec2 *psvec2_assign(struct vec2 *result, struct vec2 *a)
574 {
575 vec2_assign((mfloat_t *)result, (mfloat_t *)a);
576 return result;
577 }
578
psvec2_assign_vec2i(struct vec2 * result,struct vec2i * a)579 MATHC_INLINE struct vec2 *psvec2_assign_vec2i(struct vec2 *result, struct vec2i *a)
580 {
581 vec2_assign_vec2i((mfloat_t *)result, (mint_t *)a);
582 return result;
583 }
584
psvec2_zero(struct vec2 * result)585 MATHC_INLINE struct vec2 *psvec2_zero(struct vec2 *result)
586 {
587 vec2_zero((mfloat_t *)result);
588 return result;
589 }
590
psvec2_one(struct vec2 * result)591 MATHC_INLINE struct vec2 *psvec2_one(struct vec2 *result)
592 {
593 vec2_one((mfloat_t *)result);
594 return result;
595 }
596
psvec2_add(struct vec2 * result,struct vec2 * a,struct vec2 * b)597 MATHC_INLINE struct vec2 *psvec2_add(struct vec2 *result, struct vec2 *a, struct vec2 *b)
598 {
599 vec2_add((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
600 return result;
601 }
602
psvec2_subtract(struct vec2 * result,struct vec2 * a,struct vec2 * b)603 MATHC_INLINE struct vec2 *psvec2_subtract(struct vec2 *result, struct vec2 *a, struct vec2 *b)
604 {
605 vec2_subtract((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
606 return result;
607 }
608
psvec2_scale(struct vec2 * result,struct vec2 * a,mfloat_t scalar)609 MATHC_INLINE struct vec2 *psvec2_scale(struct vec2 *result, struct vec2 *a, mfloat_t scalar)
610 {
611 vec2_scale((mfloat_t *)result, (mfloat_t *)a, scalar);
612 return result;
613 }
614
psvec2_multiply(struct vec2 * result,struct vec2 * a,struct vec2 * b)615 MATHC_INLINE struct vec2 *psvec2_multiply(struct vec2 *result, struct vec2 *a, struct vec2 *b)
616 {
617 vec2_multiply((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
618 return result;
619 }
620
psvec2_multiply_mat2(struct vec2 * result,struct vec2 * a,struct mat2 * m)621 MATHC_INLINE struct vec2 *psvec2_multiply_mat2(struct vec2 *result, struct vec2 *a, struct mat2 *m)
622 {
623 vec2_multiply_mat2((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)m);
624 return result;
625 }
626
psvec2_divide(struct vec2 * result,struct vec2 * a,struct vec2 * b)627 MATHC_INLINE struct vec2 *psvec2_divide(struct vec2 *result, struct vec2 *a, struct vec2 *b)
628 {
629 vec2_divide((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
630 return result;
631 }
632
psvec2_snap(struct vec2 * result,struct vec2 * a,struct vec2 * b)633 MATHC_INLINE struct vec2 *psvec2_snap(struct vec2 *result, struct vec2 *a, struct vec2 *b)
634 {
635 vec2_snap((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
636 return result;
637 }
638
psvec2_negative(struct vec2 * result,struct vec2 * a)639 MATHC_INLINE struct vec2 *psvec2_negative(struct vec2 *result, struct vec2 *a)
640 {
641 vec2_negative((mfloat_t *)result, (mfloat_t *)a);
642 return result;
643 }
644
psvec2_inverse(struct vec2 * result,struct vec2 * a)645 MATHC_INLINE struct vec2 *psvec2_inverse(struct vec2 *result, struct vec2 *a)
646 {
647 vec2_inverse((mfloat_t *)result, (mfloat_t *)a);
648 return result;
649 }
650
psvec2_abs(struct vec2 * result,struct vec2 * a)651 MATHC_INLINE struct vec2 *psvec2_abs(struct vec2 *result, struct vec2 *a)
652 {
653 vec2_abs((mfloat_t *)result, (mfloat_t *)a);
654 return result;
655 }
656
psvec2_floor(struct vec2 * result,struct vec2 * a)657 MATHC_INLINE struct vec2 *psvec2_floor(struct vec2 *result, struct vec2 *a)
658 {
659 vec2_floor((mfloat_t *)result, (mfloat_t *)a);
660 return result;
661 }
662
psvec2_ceil(struct vec2 * result,struct vec2 * a)663 MATHC_INLINE struct vec2 *psvec2_ceil(struct vec2 *result, struct vec2 *a)
664 {
665 vec2_ceil((mfloat_t *)result, (mfloat_t *)a);
666 return result;
667 }
668
psvec2_round(struct vec2 * result,struct vec2 * a)669 MATHC_INLINE struct vec2 *psvec2_round(struct vec2 *result, struct vec2 *a)
670 {
671 vec2_round((mfloat_t *)result, (mfloat_t *)a);
672 return result;
673 }
674
psvec2_max(struct vec2 * result,struct vec2 * a,struct vec2 * b)675 MATHC_INLINE struct vec2 *psvec2_max(struct vec2 *result, struct vec2 *a, struct vec2 *b)
676 {
677 vec2_max((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
678 return result;
679 }
680
psvec2_min(struct vec2 * result,struct vec2 * a,struct vec2 * b)681 MATHC_INLINE struct vec2 *psvec2_min(struct vec2 *result, struct vec2 *a, struct vec2 *b)
682 {
683 vec2_min((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
684 return result;
685 }
686
psvec2_clamp(struct vec2 * result,struct vec2 * a,struct vec2 * lower,struct vec2 * higher)687 MATHC_INLINE struct vec2 *psvec2_clamp(struct vec2 *result, struct vec2 *a, struct vec2 *lower, struct vec2 *higher)
688 {
689 vec2_clamp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)lower, (mfloat_t *)higher);
690 return result;
691 }
692
psvec2_normalize(struct vec2 * result,struct vec2 * a)693 MATHC_INLINE struct vec2 *psvec2_normalize(struct vec2 *result, struct vec2 *a)
694 {
695 vec2_normalize((mfloat_t *)result, (mfloat_t *)a);
696 return result;
697 }
698
psvec2_project(struct vec2 * result,struct vec2 * a,struct vec2 * b)699 MATHC_INLINE struct vec2 *psvec2_project(struct vec2 *result, struct vec2 *a, struct vec2 *b)
700 {
701 vec2_project((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
702 return result;
703 }
704
psvec2_slide(struct vec2 * result,struct vec2 * a,struct vec2 * b)705 MATHC_INLINE struct vec2 *psvec2_slide(struct vec2 *result, struct vec2 *a, struct vec2 *b)
706 {
707 vec2_slide((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
708 return result;
709 }
710
psvec2_reflect(struct vec2 * result,struct vec2 * a,struct vec2 * b)711 MATHC_INLINE struct vec2 *psvec2_reflect(struct vec2 *result, struct vec2 *a, struct vec2 *b)
712 {
713 vec2_reflect((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
714 return result;
715 }
716
psvec2_tangent(struct vec2 * result,struct vec2 * a)717 MATHC_INLINE struct vec2 *psvec2_tangent(struct vec2 *result, struct vec2 *a)
718 {
719 vec2_tangent((mfloat_t *)result, (mfloat_t *)a);
720 return result;
721 }
722
psvec2_rotate(struct vec2 * result,struct vec2 * a,mfloat_t angle)723 MATHC_INLINE struct vec2 *psvec2_rotate(struct vec2 *result, struct vec2 *a, mfloat_t angle)
724 {
725 vec2_rotate((mfloat_t *)result, (mfloat_t *)a, angle);
726 return result;
727 }
728
psvec2_lerp(struct vec2 * result,struct vec2 * a,struct vec2 * b,mfloat_t p)729 MATHC_INLINE struct vec2 *psvec2_lerp(struct vec2 *result, struct vec2 *a, struct vec2 *b, mfloat_t p)
730 {
731 vec2_lerp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, p);
732 return result;
733 }
734
psvec2_bezier3(struct vec2 * result,struct vec2 * a,struct vec2 * b,struct vec2 * c,mfloat_t p)735 MATHC_INLINE struct vec2 *psvec2_bezier3(struct vec2 *result, struct vec2 *a, struct vec2 *b, struct vec2 *c, mfloat_t p)
736 {
737 vec2_bezier3((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, (mfloat_t *)c, p);
738 return result;
739 }
740
psvec2_bezier4(struct vec2 * result,struct vec2 * a,struct vec2 * b,struct vec2 * c,struct vec2 * d,mfloat_t p)741 MATHC_INLINE struct vec2 *psvec2_bezier4(struct vec2 *result, struct vec2 *a, struct vec2 *b, struct vec2 *c, struct vec2 *d, mfloat_t p)
742 {
743 vec2_bezier4((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, (mfloat_t *)c, (mfloat_t *)d, p);
744 return result;
745 }
746
psvec2_dot(struct vec2 * a,struct vec2 * b)747 MATHC_INLINE mfloat_t psvec2_dot(struct vec2 *a, struct vec2 *b)
748 {
749 return vec2_dot((mfloat_t *)a, (mfloat_t *)b);
750 }
751
psvec2_angle(struct vec2 * a)752 MATHC_INLINE mfloat_t psvec2_angle(struct vec2 *a)
753 {
754 return vec2_angle((mfloat_t *)a);
755 }
756
psvec2_length_squared(struct vec2 * a)757 MATHC_INLINE mfloat_t psvec2_length_squared(struct vec2 *a)
758 {
759 return vec2_length_squared((mfloat_t *)a);
760 }
761
psvec2_length(struct vec2 * a)762 MATHC_INLINE mfloat_t psvec2_length(struct vec2 *a)
763 {
764 return vec2_length((mfloat_t *)a);
765 }
766
psvec2_distance(struct vec2 * a,struct vec2 * b)767 MATHC_INLINE mfloat_t psvec2_distance(struct vec2 *a, struct vec2 *b)
768 {
769 return vec2_distance((mfloat_t *)a, (mfloat_t *)b);
770 }
771
psvec2_distance_squared(struct vec2 * a,struct vec2 * b)772 MATHC_INLINE mfloat_t psvec2_distance_squared(struct vec2 *a, struct vec2 *b)
773 {
774 return vec2_distance_squared((mfloat_t *)a, (mfloat_t *)b);
775 }
776
777 /* Vector 2D Integer */
psvec2i_is_zero(struct vec2i * a)778 MATHC_INLINE bool psvec2i_is_zero(struct vec2i *a)
779 {
780 return vec2i_is_zero((mint_t *)a);
781 }
782
psvec2i_is_equal(struct vec2i * a,struct vec2i * b)783 MATHC_INLINE bool psvec2i_is_equal(struct vec2i *a, struct vec2i *b)
784 {
785 return vec2i_is_equal((mint_t *)a, (mint_t *)b);
786 }
787
psvec2i(struct vec2i * result,mint_t x,mint_t y)788 MATHC_INLINE struct vec2i *psvec2i(struct vec2i *result, mint_t x, mint_t y)
789 {
790 vec2i((mint_t *)result, x, y);
791 return result;
792 }
793
psvec2i_assign(struct vec2i * result,struct vec2i * a)794 MATHC_INLINE struct vec2i *psvec2i_assign(struct vec2i *result, struct vec2i *a)
795 {
796 vec2i_assign((mint_t *)result, (mint_t *)a);
797 return result;
798 }
799
psvec2i_assign_vec2(struct vec2i * result,struct vec2 * a)800 MATHC_INLINE struct vec2i *psvec2i_assign_vec2(struct vec2i *result, struct vec2 *a)
801 {
802 vec2i_assign_vec2((mint_t *)result, (mfloat_t *)a);
803 return result;
804 }
805
psvec2i_zero(struct vec2i * result)806 MATHC_INLINE struct vec2i *psvec2i_zero(struct vec2i *result)
807 {
808 vec2i_zero((mint_t *)result);
809 return result;
810 }
811
psvec2i_one(struct vec2i * result)812 MATHC_INLINE struct vec2i *psvec2i_one(struct vec2i *result)
813 {
814 vec2i_one((mint_t *)result);
815 return result;
816 }
817
psvec2i_add(struct vec2i * result,struct vec2i * a,struct vec2i * b)818 MATHC_INLINE struct vec2i *psvec2i_add(struct vec2i *result, struct vec2i *a, struct vec2i *b)
819 {
820 vec2i_add((mint_t *)result, (mint_t *)a, (mint_t *)b);
821 return result;
822 }
823
psvec2i_subtract(struct vec2i * result,struct vec2i * a,struct vec2i * b)824 MATHC_INLINE struct vec2i *psvec2i_subtract(struct vec2i *result, struct vec2i *a, struct vec2i *b)
825 {
826 vec2i_subtract((mint_t *)result, (mint_t *)a, (mint_t *)b);
827 return result;
828 }
829
psvec2i_scale(struct vec2i * result,struct vec2i * a,mfloat_t scalar)830 MATHC_INLINE struct vec2i *psvec2i_scale(struct vec2i *result, struct vec2i *a, mfloat_t scalar)
831 {
832 vec2i_scale((mint_t *)result, (mint_t *)a, scalar);
833 return result;
834 }
835
psvec2i_multiply(struct vec2i * result,struct vec2i * a,struct vec2i * b)836 MATHC_INLINE struct vec2i *psvec2i_multiply(struct vec2i *result, struct vec2i *a, struct vec2i *b)
837 {
838 vec2i_multiply((mint_t *)result, (mint_t *)a, (mint_t *)b);
839 return result;
840 }
841
psvec2i_multiply_mat2(struct vec2i * result,struct vec2i * a,struct mat2 * m)842 MATHC_INLINE struct vec2i *psvec2i_multiply_mat2(struct vec2i *result, struct vec2i *a, struct mat2 *m)
843 {
844 vec2i_multiply_mat2((mint_t *)result, (mint_t *)a, (mfloat_t *)m);
845 return result;
846 }
847
psvec2i_divide(struct vec2i * result,struct vec2i * a,struct vec2i * b)848 MATHC_INLINE struct vec2i *psvec2i_divide(struct vec2i *result, struct vec2i *a, struct vec2i *b)
849 {
850 vec2i_divide((mint_t *)result, (mint_t *)a, (mint_t *)b);
851 return result;
852 }
853
psvec2i_snap(struct vec2i * result,struct vec2i * a,struct vec2i * b)854 MATHC_INLINE struct vec2i *psvec2i_snap(struct vec2i *result, struct vec2i *a, struct vec2i *b)
855 {
856 vec2i_snap((mint_t *)result, (mint_t *)a, (mint_t *)b);
857 return result;
858 }
859
psvec2i_negative(struct vec2i * result,struct vec2i * a)860 MATHC_INLINE struct vec2i *psvec2i_negative(struct vec2i *result, struct vec2i *a)
861 {
862 vec2i_negative((mint_t *)result, (mint_t *)a);
863 return result;
864 }
865
psvec2i_inverse(struct vec2i * result,struct vec2i * a)866 MATHC_INLINE struct vec2i *psvec2i_inverse(struct vec2i *result, struct vec2i *a)
867 {
868 vec2i_inverse((mint_t *)result, (mint_t *)a);
869 return result;
870 }
871
psvec2i_abs(struct vec2i * result,struct vec2i * a)872 MATHC_INLINE struct vec2i *psvec2i_abs(struct vec2i *result, struct vec2i *a)
873 {
874 vec2i_abs((mint_t *)result, (mint_t *)a);
875 return result;
876 }
877
psvec2i_floor(struct vec2i * result,struct vec2 * a)878 MATHC_INLINE struct vec2i *psvec2i_floor(struct vec2i *result, struct vec2 *a)
879 {
880 vec2i_floor((mint_t *)result, (mfloat_t *)a);
881 return result;
882 }
883
psvec2i_ceil(struct vec2i * result,struct vec2 * a)884 MATHC_INLINE struct vec2i *psvec2i_ceil(struct vec2i *result, struct vec2 *a)
885 {
886 vec2i_ceil((mint_t *)result, (mfloat_t *)a);
887 return result;
888 }
889
psvec2i_round(struct vec2i * result,struct vec2 * a)890 MATHC_INLINE struct vec2i *psvec2i_round(struct vec2i *result, struct vec2 *a)
891 {
892 vec2i_round((mint_t *)result, (mfloat_t *)a);
893 return result;
894 }
895
psvec2i_max(struct vec2i * result,struct vec2i * a,struct vec2i * b)896 MATHC_INLINE struct vec2i *psvec2i_max(struct vec2i *result, struct vec2i *a, struct vec2i *b)
897 {
898 vec2i_max((mint_t *)result, (mint_t *)a, (mint_t *)b);
899 return result;
900 }
901
psvec2i_min(struct vec2i * result,struct vec2i * a,struct vec2i * b)902 MATHC_INLINE struct vec2i *psvec2i_min(struct vec2i *result, struct vec2i *a, struct vec2i *b)
903 {
904 vec2i_min((mint_t *)result, (mint_t *)a, (mint_t *)b);
905 return result;
906 }
907
psvec2i_clamp(struct vec2i * result,struct vec2i * a,struct vec2i * lower,struct vec2i * higher)908 MATHC_INLINE struct vec2i *psvec2i_clamp(struct vec2i *result, struct vec2i *a, struct vec2i *lower, struct vec2i *higher)
909 {
910 vec2i_clamp((mint_t *)result, (mint_t *)a, (mint_t *)lower, (mint_t *)higher);
911 return result;
912 }
913
psvec2i_normalize(struct vec2i * result,struct vec2i * a)914 MATHC_INLINE struct vec2i *psvec2i_normalize(struct vec2i *result, struct vec2i *a)
915 {
916 vec2i_normalize((mint_t *)result, (mint_t *)a);
917 return result;
918 }
919
psvec2i_project(struct vec2i * result,struct vec2i * a,struct vec2i * b)920 MATHC_INLINE struct vec2i *psvec2i_project(struct vec2i *result, struct vec2i *a, struct vec2i *b)
921 {
922 vec2i_project((mint_t *)result, (mint_t *)a, (mint_t *)b);
923 return result;
924 }
925
psvec2i_slide(struct vec2i * result,struct vec2i * a,struct vec2i * b)926 MATHC_INLINE struct vec2i *psvec2i_slide(struct vec2i *result, struct vec2i *a, struct vec2i *b)
927 {
928 vec2i_slide((mint_t *)result, (mint_t *)a, (mint_t *)b);
929 return result;
930 }
931
psvec2i_reflect(struct vec2i * result,struct vec2i * a,struct vec2i * b)932 MATHC_INLINE struct vec2i *psvec2i_reflect(struct vec2i *result, struct vec2i *a, struct vec2i *b)
933 {
934 vec2i_reflect((mint_t *)result, (mint_t *)a, (mint_t *)b);
935 return result;
936 }
937
psvec2i_tangent(struct vec2i * result,struct vec2i * a)938 MATHC_INLINE struct vec2i *psvec2i_tangent(struct vec2i *result, struct vec2i *a)
939 {
940 vec2i_tangent((mint_t *)result, (mint_t *)a);
941 return result;
942 }
943
psvec2i_rotate(struct vec2i * result,struct vec2i * a,mfloat_t angle)944 MATHC_INLINE struct vec2i *psvec2i_rotate(struct vec2i *result, struct vec2i *a, mfloat_t angle)
945 {
946 vec2i_rotate((mint_t *)result, (mint_t *)a, angle);
947 return result;
948 }
949
psvec2i_lerp(struct vec2i * result,struct vec2i * a,struct vec2i * b,mfloat_t p)950 MATHC_INLINE struct vec2i *psvec2i_lerp(struct vec2i *result, struct vec2i *a, struct vec2i *b, mfloat_t p)
951 {
952 vec2i_lerp((mint_t *)result, (mint_t *)a, (mint_t *)b, p);
953 return result;
954 }
955
psvec2i_bezier3(struct vec2i * result,struct vec2i * a,struct vec2i * b,struct vec2i * c,mfloat_t p)956 MATHC_INLINE struct vec2i *psvec2i_bezier3(struct vec2i *result, struct vec2i *a, struct vec2i *b, struct vec2i *c, mfloat_t p)
957 {
958 vec2i_bezier3((mint_t *)result, (mint_t *)a, (mint_t *)b, (mint_t *)c, p);
959 return result;
960 }
961
psvec2i_bezier4(struct vec2i * result,struct vec2i * a,struct vec2i * b,struct vec2i * c,struct vec2i * d,mfloat_t p)962 MATHC_INLINE struct vec2i *psvec2i_bezier4(struct vec2i *result, struct vec2i *a, struct vec2i *b, struct vec2i *c, struct vec2i *d, mfloat_t p)
963 {
964 vec2i_bezier4((mint_t *)result, (mint_t *)a, (mint_t *)b, (mint_t *)c, (mint_t *)d, p);
965 return result;
966 }
967
psvec2i_dot(struct vec2i * a,struct vec2i * b)968 MATHC_INLINE mint_t psvec2i_dot(struct vec2i *a, struct vec2i *b)
969 {
970 return vec2i_dot((mint_t *)a, (mint_t *)b);
971 }
972
psvec2i_angle(struct vec2i * a)973 MATHC_INLINE mfloat_t psvec2i_angle(struct vec2i *a)
974 {
975 return vec2i_angle((mint_t *)a);
976 }
977
psvec2i_length_squared(struct vec2i * a)978 MATHC_INLINE mint_t psvec2i_length_squared(struct vec2i *a)
979 {
980 return vec2i_length_squared((mint_t *)a);
981 }
982
psvec2i_length(struct vec2i * a)983 MATHC_INLINE mfloat_t psvec2i_length(struct vec2i *a)
984 {
985 return vec2i_length((mint_t *)a);
986 }
987
psvec2i_distance(struct vec2i * a,struct vec2i * b)988 MATHC_INLINE mfloat_t psvec2i_distance(struct vec2i *a, struct vec2i *b)
989 {
990 return vec2i_distance((mint_t *)a, (mint_t *)b);
991 }
992
psvec2i_distance_squared(struct vec2i * a,struct vec2i * b)993 MATHC_INLINE mint_t psvec2i_distance_squared(struct vec2i *a, struct vec2i *b)
994 {
995 return vec2i_distance_squared((mint_t *)a, (mint_t *)b);
996 }
997
998 /* Vector 3D */
psvec3_is_zero(struct vec3 * a)999 MATHC_INLINE bool psvec3_is_zero(struct vec3 *a)
1000 {
1001 return vec3_is_zero((mfloat_t *)a);
1002 }
1003
psvec3_is_near_zero(struct vec3 * a,mfloat_t epsilon)1004 MATHC_INLINE bool psvec3_is_near_zero(struct vec3 *a, mfloat_t epsilon)
1005 {
1006 return vec3_is_near_zero((mfloat_t *)a, epsilon);
1007 }
1008
psvec3_is_equal(struct vec3 * a,struct vec3 * b)1009 MATHC_INLINE bool psvec3_is_equal(struct vec3 *a, struct vec3 *b)
1010 {
1011 return vec3_is_equal((mfloat_t *)a, (mfloat_t *)b);
1012 }
1013
psvec3_is_nearly_equal(struct vec3 * a,struct vec3 * b,mfloat_t epsilon)1014 MATHC_INLINE bool psvec3_is_nearly_equal(struct vec3 *a, struct vec3 *b, mfloat_t epsilon)
1015 {
1016 return vec3_is_nearly_equal((mfloat_t *)a, (mfloat_t *)b, epsilon);
1017 }
1018
psvec3(struct vec3 * result,mfloat_t x,mfloat_t y,mfloat_t z)1019 MATHC_INLINE struct vec3 *psvec3(struct vec3 *result, mfloat_t x, mfloat_t y, mfloat_t z)
1020 {
1021 vec3((mfloat_t *)result, x, y, z);
1022 return result;
1023 }
1024
psvec3_assign(struct vec3 * result,struct vec3 * a)1025 MATHC_INLINE struct vec3 *psvec3_assign(struct vec3 *result, struct vec3 *a)
1026 {
1027 vec3_assign((mfloat_t *)result, (mfloat_t *)a);
1028 return result;
1029 }
1030
psvec3_assign_vec3i(struct vec3 * result,struct vec3i * a)1031 MATHC_INLINE struct vec3 *psvec3_assign_vec3i(struct vec3 *result, struct vec3i *a)
1032 {
1033 vec3_assign_vec3i((mfloat_t *)result, (mint_t *)a);
1034 return result;
1035 }
1036
psvec3_zero(struct vec3 * result)1037 MATHC_INLINE struct vec3 *psvec3_zero(struct vec3 *result)
1038 {
1039 vec3_zero((mfloat_t *)result);
1040 return result;
1041 }
1042
psvec3_one(struct vec3 * result)1043 MATHC_INLINE struct vec3 *psvec3_one(struct vec3 *result)
1044 {
1045 vec3_one((mfloat_t *)result);
1046 return result;
1047 }
1048
psvec3_add(struct vec3 * result,struct vec3 * a,struct vec3 * b)1049 MATHC_INLINE struct vec3 *psvec3_add(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1050 {
1051 vec3_add((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1052 return result;
1053 }
1054
psvec3_subtract(struct vec3 * result,struct vec3 * a,struct vec3 * b)1055 MATHC_INLINE struct vec3 *psvec3_subtract(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1056 {
1057 vec3_subtract((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1058 return result;
1059 }
1060
psvec3_scale(struct vec3 * result,struct vec3 * a,mfloat_t scalar)1061 MATHC_INLINE struct vec3 *psvec3_scale(struct vec3 *result, struct vec3 *a, mfloat_t scalar)
1062 {
1063 vec3_scale((mfloat_t *)result, (mfloat_t *)a, scalar);
1064 return result;
1065 }
1066
psvec3_multiply(struct vec3 * result,struct vec3 * a,struct vec3 * b)1067 MATHC_INLINE struct vec3 *psvec3_multiply(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1068 {
1069 vec3_multiply((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1070 return result;
1071 }
1072
psvec3_multiply_mat3(struct vec3 * result,struct vec3 * a,struct mat3 * m)1073 MATHC_INLINE struct vec3 *psvec3_multiply_mat3(struct vec3 *result, struct vec3 *a, struct mat3 *m)
1074 {
1075 vec3_multiply_mat3((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)m);
1076 return result;
1077 }
1078
psvec3_divide(struct vec3 * result,struct vec3 * a,struct vec3 * b)1079 MATHC_INLINE struct vec3 *psvec3_divide(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1080 {
1081 vec3_divide((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1082 return result;
1083 }
1084
psvec3_snap(struct vec3 * result,struct vec3 * a,struct vec3 * b)1085 MATHC_INLINE struct vec3 *psvec3_snap(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1086 {
1087 vec3_snap((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1088 return result;
1089 }
1090
psvec3_negative(struct vec3 * result,struct vec3 * a)1091 MATHC_INLINE struct vec3 *psvec3_negative(struct vec3 *result, struct vec3 *a)
1092 {
1093 vec3_negative((mfloat_t *)result, (mfloat_t *)a);
1094 return result;
1095 }
1096
psvec3_inverse(struct vec3 * result,struct vec3 * a)1097 MATHC_INLINE struct vec3 *psvec3_inverse(struct vec3 *result, struct vec3 *a)
1098 {
1099 vec3_inverse((mfloat_t *)result, (mfloat_t *)a);
1100 return result;
1101 }
1102
psvec3_abs(struct vec3 * result,struct vec3 * a)1103 MATHC_INLINE struct vec3 *psvec3_abs(struct vec3 *result, struct vec3 *a)
1104 {
1105 vec3_abs((mfloat_t *)result, (mfloat_t *)a);
1106 return result;
1107 }
1108
psvec3_floor(struct vec3 * result,struct vec3 * a)1109 MATHC_INLINE struct vec3 *psvec3_floor(struct vec3 *result, struct vec3 *a)
1110 {
1111 vec3_floor((mfloat_t *)result, (mfloat_t *)a);
1112 return result;
1113 }
1114
psvec3_ceil(struct vec3 * result,struct vec3 * a)1115 MATHC_INLINE struct vec3 *psvec3_ceil(struct vec3 *result, struct vec3 *a)
1116 {
1117 vec3_ceil((mfloat_t *)result, (mfloat_t *)a);
1118 return result;
1119 }
1120
psvec3_round(struct vec3 * result,struct vec3 * a)1121 MATHC_INLINE struct vec3 *psvec3_round(struct vec3 *result, struct vec3 *a)
1122 {
1123 vec3_round((mfloat_t *)result, (mfloat_t *)a);
1124 return result;
1125 }
1126
psvec3_max(struct vec3 * result,struct vec3 * a,struct vec3 * b)1127 MATHC_INLINE struct vec3 *psvec3_max(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1128 {
1129 vec3_max((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1130 return result;
1131 }
1132
psvec3_min(struct vec3 * result,struct vec3 * a,struct vec3 * b)1133 MATHC_INLINE struct vec3 *psvec3_min(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1134 {
1135 vec3_min((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1136 return result;
1137 }
1138
psvec3_clamp(struct vec3 * result,struct vec3 * a,struct vec3 * lower,struct vec3 * higher)1139 MATHC_INLINE struct vec3 *psvec3_clamp(struct vec3 *result, struct vec3 *a, struct vec3 *lower, struct vec3 *higher)
1140 {
1141 vec3_clamp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)lower, (mfloat_t *)higher);
1142 return result;
1143 }
1144
psvec3_cross(struct vec3 * result,struct vec3 * a,struct vec3 * b)1145 MATHC_INLINE struct vec3 *psvec3_cross(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1146 {
1147 vec3_cross((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1148 return result;
1149 }
1150
psvec3_normalize(struct vec3 * result,struct vec3 * a)1151 MATHC_INLINE struct vec3 *psvec3_normalize(struct vec3 *result, struct vec3 *a)
1152 {
1153 vec3_normalize((mfloat_t *)result, (mfloat_t *)a);
1154 return result;
1155 }
1156
psvec3_project(struct vec3 * result,struct vec3 * a,struct vec3 * b)1157 MATHC_INLINE struct vec3 *psvec3_project(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1158 {
1159 vec3_project((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1160 return result;
1161 }
1162
psvec3_slide(struct vec3 * result,struct vec3 * a,struct vec3 * b)1163 MATHC_INLINE struct vec3 *psvec3_slide(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1164 {
1165 vec3_slide((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1166 return result;
1167 }
1168
psvec3_reflect(struct vec3 * result,struct vec3 * a,struct vec3 * b)1169 MATHC_INLINE struct vec3 *psvec3_reflect(struct vec3 *result, struct vec3 *a, struct vec3 *b)
1170 {
1171 vec3_reflect((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1172 return result;
1173 }
1174
psvec3_lerp(struct vec3 * result,struct vec3 * a,struct vec3 * b,mfloat_t p)1175 MATHC_INLINE struct vec3 *psvec3_lerp(struct vec3 *result, struct vec3 *a, struct vec3 *b, mfloat_t p)
1176 {
1177 vec3_lerp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, p);
1178 return result;
1179 }
1180
psvec3_bezier3(struct vec3 * result,struct vec3 * a,struct vec3 * b,struct vec3 * c,mfloat_t p)1181 MATHC_INLINE struct vec3 *psvec3_bezier3(struct vec3 *result, struct vec3 *a, struct vec3 *b, struct vec3 *c, mfloat_t p)
1182 {
1183 vec3_bezier3((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, (mfloat_t *)c, p);
1184 return result;
1185 }
1186
psvec3_bezier4(struct vec3 * result,struct vec3 * a,struct vec3 * b,struct vec3 * c,struct vec3 * d,mfloat_t p)1187 MATHC_INLINE struct vec3 *psvec3_bezier4(struct vec3 *result, struct vec3 *a, struct vec3 *b, struct vec3 *c, struct vec3 *d, mfloat_t p)
1188 {
1189 vec3_bezier4((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, (mfloat_t *)c, (mfloat_t *)d, p);
1190 return result;
1191 }
1192
psvec3_dot(struct vec3 * a,struct vec3 * b)1193 MATHC_INLINE mfloat_t psvec3_dot(struct vec3 *a, struct vec3 *b)
1194 {
1195 return vec3_dot((mfloat_t *)a, (mfloat_t *)b);
1196 }
1197
psvec3_length(struct vec3 * a)1198 MATHC_INLINE mfloat_t psvec3_length(struct vec3 *a)
1199 {
1200 return vec3_length((mfloat_t *)a);
1201 }
1202
psvec3_length_squared(struct vec3 * a)1203 MATHC_INLINE mfloat_t psvec3_length_squared(struct vec3 *a)
1204 {
1205 return vec3_length_squared((mfloat_t *)a);
1206 }
1207
psvec3_distance(struct vec3 * a,struct vec3 * b)1208 MATHC_INLINE mfloat_t psvec3_distance(struct vec3 *a, struct vec3 *b)
1209 {
1210 return vec3_distance((mfloat_t *)a, (mfloat_t *)b);
1211 }
1212
psvec3_distance_squared(struct vec3 * a,struct vec3 * b)1213 MATHC_INLINE mfloat_t psvec3_distance_squared(struct vec3 *a, struct vec3 *b)
1214 {
1215 return vec3_distance_squared((mfloat_t *)a, (mfloat_t *)b);
1216 }
1217
1218 /* Vector 3D Integer */
psvec3i_is_zero(struct vec3i * a)1219 MATHC_INLINE bool psvec3i_is_zero(struct vec3i *a)
1220 {
1221 return vec3i_is_zero((mint_t *)a);
1222 }
1223
psvec3i_is_equal(struct vec3i * a,struct vec3i * b)1224 MATHC_INLINE bool psvec3i_is_equal(struct vec3i *a, struct vec3i *b)
1225 {
1226 return vec3i_is_equal((mint_t *)a, (mint_t *)b);
1227 }
1228
psvec3i(struct vec3i * result,mint_t x,mint_t y,mint_t z)1229 MATHC_INLINE struct vec3i *psvec3i(struct vec3i *result, mint_t x, mint_t y, mint_t z)
1230 {
1231 vec3i((mint_t *)result, x, y, z);
1232 return result;
1233 }
1234
psvec3i_assign(struct vec3i * result,struct vec3i * a)1235 MATHC_INLINE struct vec3i *psvec3i_assign(struct vec3i *result, struct vec3i *a)
1236 {
1237 vec3i_assign((mint_t *)result, (mint_t *)a);
1238 return result;
1239 }
1240
psvec3i_assign_vec3(struct vec3i * result,struct vec3 * a)1241 MATHC_INLINE struct vec3i *psvec3i_assign_vec3(struct vec3i *result, struct vec3 *a)
1242 {
1243 vec3i_assign_vec3((mint_t *)result, (mfloat_t *)a);
1244 return result;
1245 }
1246
psvec3i_zero(struct vec3i * result)1247 MATHC_INLINE struct vec3i *psvec3i_zero(struct vec3i *result)
1248 {
1249 vec3i_zero((mint_t *)result);
1250 return result;
1251 }
1252
psvec3i_one(struct vec3i * result)1253 MATHC_INLINE struct vec3i *psvec3i_one(struct vec3i *result)
1254 {
1255 vec3i_one((mint_t *)result);
1256 return result;
1257 }
1258
psvec3i_add(struct vec3i * result,struct vec3i * a,struct vec3i * b)1259 MATHC_INLINE struct vec3i *psvec3i_add(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1260 {
1261 vec3i_add((mint_t *)result, (mint_t *)a, (mint_t *)b);
1262 return result;
1263 }
1264
psvec3i_subtract(struct vec3i * result,struct vec3i * a,struct vec3i * b)1265 MATHC_INLINE struct vec3i *psvec3i_subtract(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1266 {
1267 vec3i_subtract((mint_t *)result, (mint_t *)a, (mint_t *)b);
1268 return result;
1269 }
1270
psvec3i_scale(struct vec3i * result,struct vec3i * a,mfloat_t scalar)1271 MATHC_INLINE struct vec3i *psvec3i_scale(struct vec3i *result, struct vec3i *a, mfloat_t scalar)
1272 {
1273 vec3i_scale((mint_t *)result, (mint_t *)a, scalar);
1274 return result;
1275 }
1276
psvec3i_multiply(struct vec3i * result,struct vec3i * a,struct vec3i * b)1277 MATHC_INLINE struct vec3i *psvec3i_multiply(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1278 {
1279 vec3i_multiply((mint_t *)result, (mint_t *)a, (mint_t *)b);
1280 return result;
1281 }
1282
psvec3i_multiply_mat3(struct vec3i * result,struct vec3i * a,struct mat3 * m)1283 MATHC_INLINE struct vec3i *psvec3i_multiply_mat3(struct vec3i *result, struct vec3i *a, struct mat3 *m)
1284 {
1285 vec3i_multiply_mat3((mint_t *)result, (mint_t *)a, (mfloat_t *)m);
1286 return result;
1287 }
1288
psvec3i_divide(struct vec3i * result,struct vec3i * a,struct vec3i * b)1289 MATHC_INLINE struct vec3i *psvec3i_divide(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1290 {
1291 vec3i_divide((mint_t *)result, (mint_t *)a, (mint_t *)b);
1292 return result;
1293 }
1294
psvec3i_snap(struct vec3i * result,struct vec3i * a,struct vec3i * b)1295 MATHC_INLINE struct vec3i *psvec3i_snap(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1296 {
1297 vec3i_snap((mint_t *)result, (mint_t *)a, (mint_t *)b);
1298 return result;
1299 }
1300
psvec3i_negative(struct vec3i * result,struct vec3i * a)1301 MATHC_INLINE struct vec3i *psvec3i_negative(struct vec3i *result, struct vec3i *a)
1302 {
1303 vec3i_negative((mint_t *)result, (mint_t *)a);
1304 return result;
1305 }
1306
psvec3i_inverse(struct vec3i * result,struct vec3i * a)1307 MATHC_INLINE struct vec3i *psvec3i_inverse(struct vec3i *result, struct vec3i *a)
1308 {
1309 vec3i_inverse((mint_t *)result, (mint_t *)a);
1310 return result;
1311 }
1312
psvec3i_abs(struct vec3i * result,struct vec3i * a)1313 MATHC_INLINE struct vec3i *psvec3i_abs(struct vec3i *result, struct vec3i *a)
1314 {
1315 vec3i_abs((mint_t *)result, (mint_t *)a);
1316 return result;
1317 }
1318
psvec3i_floor(struct vec3i * result,struct vec3 * a)1319 MATHC_INLINE struct vec3i *psvec3i_floor(struct vec3i *result, struct vec3 *a)
1320 {
1321 vec3i_floor((mint_t *)result, (mfloat_t *)a);
1322 return result;
1323 }
1324
psvec3i_ceil(struct vec3i * result,struct vec3 * a)1325 MATHC_INLINE struct vec3i *psvec3i_ceil(struct vec3i *result, struct vec3 *a)
1326 {
1327 vec3i_ceil((mint_t *)result, (mfloat_t *)a);
1328 return result;
1329 }
1330
psvec3i_round(struct vec3i * result,struct vec3 * a)1331 MATHC_INLINE struct vec3i *psvec3i_round(struct vec3i *result, struct vec3 *a)
1332 {
1333 vec3i_round((mint_t *)result, (mfloat_t *)a);
1334 return result;
1335 }
1336
psvec3i_max(struct vec3i * result,struct vec3i * a,struct vec3i * b)1337 MATHC_INLINE struct vec3i *psvec3i_max(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1338 {
1339 vec3i_max((mint_t *)result, (mint_t *)a, (mint_t *)b);
1340 return result;
1341 }
1342
psvec3i_min(struct vec3i * result,struct vec3i * a,struct vec3i * b)1343 MATHC_INLINE struct vec3i *psvec3i_min(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1344 {
1345 vec3i_min((mint_t *)result, (mint_t *)a, (mint_t *)b);
1346 return result;
1347 }
1348
psvec3i_clamp(struct vec3i * result,struct vec3i * a,struct vec3i * lower,struct vec3i * higher)1349 MATHC_INLINE struct vec3i *psvec3i_clamp(struct vec3i *result, struct vec3i *a, struct vec3i *lower, struct vec3i *higher)
1350 {
1351 vec3i_clamp((mint_t *)result, (mint_t *)a, (mint_t *)lower, (mint_t *)higher);
1352 return result;
1353 }
1354
psvec3i_cross(struct vec3i * result,struct vec3i * a,struct vec3i * b)1355 MATHC_INLINE struct vec3i *psvec3i_cross(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1356 {
1357 vec3i_cross((mint_t *)result, (mint_t *)a, (mint_t *)b);
1358 return result;
1359 }
1360
psvec3i_normalize(struct vec3i * result,struct vec3i * a)1361 MATHC_INLINE struct vec3i *psvec3i_normalize(struct vec3i *result, struct vec3i *a)
1362 {
1363 vec3i_normalize((mint_t *)result, (mint_t *)a);
1364 return result;
1365 }
1366
psvec3i_project(struct vec3i * result,struct vec3i * a,struct vec3i * b)1367 MATHC_INLINE struct vec3i *psvec3i_project(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1368 {
1369 vec3i_project((mint_t *)result, (mint_t *)a, (mint_t *)b);
1370 return result;
1371 }
1372
psvec3i_slide(struct vec3i * result,struct vec3i * a,struct vec3i * b)1373 MATHC_INLINE struct vec3i *psvec3i_slide(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1374 {
1375 vec3i_slide((mint_t *)result, (mint_t *)a, (mint_t *)b);
1376 return result;
1377 }
1378
psvec3i_reflect(struct vec3i * result,struct vec3i * a,struct vec3i * b)1379 MATHC_INLINE struct vec3i *psvec3i_reflect(struct vec3i *result, struct vec3i *a, struct vec3i *b)
1380 {
1381 vec3i_reflect((mint_t *)result, (mint_t *)a, (mint_t *)b);
1382 return result;
1383 }
1384
psvec3i_lerp(struct vec3i * result,struct vec3i * a,struct vec3i * b,mfloat_t p)1385 MATHC_INLINE struct vec3i *psvec3i_lerp(struct vec3i *result, struct vec3i *a, struct vec3i *b, mfloat_t p)
1386 {
1387 vec3i_lerp((mint_t *)result, (mint_t *)a, (mint_t *)b, p);
1388 return result;
1389 }
1390
psvec3i_bezier3(struct vec3i * result,struct vec3i * a,struct vec3i * b,struct vec3i * c,mfloat_t p)1391 MATHC_INLINE struct vec3i *psvec3i_bezier3(struct vec3i *result, struct vec3i *a, struct vec3i *b, struct vec3i *c, mfloat_t p)
1392 {
1393 vec3i_bezier3((mint_t *)result, (mint_t *)a, (mint_t *)b, (mint_t *)c, p);
1394 return result;
1395 }
1396
psvec3i_bezier4(struct vec3i * result,struct vec3i * a,struct vec3i * b,struct vec3i * c,struct vec3i * d,mfloat_t p)1397 MATHC_INLINE struct vec3i *psvec3i_bezier4(struct vec3i *result, struct vec3i *a, struct vec3i *b, struct vec3i *c, struct vec3i *d, mfloat_t p)
1398 {
1399 vec3i_bezier4((mint_t *)result, (mint_t *)a, (mint_t *)b, (mint_t *)c, (mint_t *)d, p);
1400 return result;
1401 }
1402
psvec3i_dot(struct vec3i * a,struct vec3i * b)1403 MATHC_INLINE mint_t psvec3i_dot(struct vec3i *a, struct vec3i *b)
1404 {
1405 return vec3i_dot((mint_t *)a, (mint_t *)b);
1406 }
1407
psvec3i_length(struct vec3i * a)1408 MATHC_INLINE mfloat_t psvec3i_length(struct vec3i *a)
1409 {
1410 return vec3i_length((mint_t *)a);
1411 }
1412
psvec3i_length_squared(struct vec3i * a)1413 MATHC_INLINE mint_t psvec3i_length_squared(struct vec3i *a)
1414 {
1415 return vec3i_length_squared((mint_t *)a);
1416 }
1417
psvec3i_distance(struct vec3i * a,struct vec3i * b)1418 MATHC_INLINE mfloat_t psvec3i_distance(struct vec3i *a, struct vec3i *b)
1419 {
1420 return vec3i_distance((mint_t *)a, (mint_t *)b);
1421 }
1422
psvec3i_distance_squared(struct vec3i * a,struct vec3i * b)1423 MATHC_INLINE mint_t psvec3i_distance_squared(struct vec3i *a, struct vec3i *b)
1424 {
1425 return vec3i_distance_squared((mint_t *)a, (mint_t *)b);
1426 }
1427
1428 /* Vector 4D */
psvec4_is_zero(struct vec4 * a)1429 MATHC_INLINE bool psvec4_is_zero(struct vec4 *a)
1430 {
1431 return vec4_is_zero((mfloat_t *)a);
1432 }
1433
psvec4_is_near_zero(struct vec4 * a,mfloat_t epsilon)1434 MATHC_INLINE bool psvec4_is_near_zero(struct vec4 *a, mfloat_t epsilon)
1435 {
1436 return vec4_is_near_zero((mfloat_t *)a, epsilon);
1437 }
1438
psvec4_is_equal(struct vec4 * a,struct vec4 * b)1439 MATHC_INLINE bool psvec4_is_equal(struct vec4 *a, struct vec4 *b)
1440 {
1441 return vec4_is_equal((mfloat_t *)a, (mfloat_t *)b);
1442 }
1443
psvec4_is_nearly_equal(struct vec4 * a,struct vec4 * b,mfloat_t epsilon)1444 MATHC_INLINE bool psvec4_is_nearly_equal(struct vec4 *a, struct vec4 *b, mfloat_t epsilon)
1445 {
1446 return vec4_is_nearly_equal((mfloat_t *)a, (mfloat_t *)b, epsilon);
1447 }
1448
psvec4(struct vec4 * result,mfloat_t x,mfloat_t y,mfloat_t z,mfloat_t w)1449 MATHC_INLINE struct vec4 *psvec4(struct vec4 *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
1450 {
1451 vec4((mfloat_t *)result, x, y, z, w);
1452 return result;
1453 }
1454
psvec4_assign(struct vec4 * result,struct vec4 * a)1455 MATHC_INLINE struct vec4 *psvec4_assign(struct vec4 *result, struct vec4 *a)
1456 {
1457 vec4_assign((mfloat_t *)result, (mfloat_t *)a);
1458 return result;
1459 }
1460
psvec4_assign_vec4i(struct vec4 * result,struct vec4i * a)1461 MATHC_INLINE struct vec4 *psvec4_assign_vec4i(struct vec4 *result, struct vec4i *a)
1462 {
1463 vec4_assign_vec4i((mfloat_t *)result, (mint_t *)a);
1464 return result;
1465 }
1466
psvec4_zero(struct vec4 * result)1467 MATHC_INLINE struct vec4 *psvec4_zero(struct vec4 *result)
1468 {
1469 vec4_zero((mfloat_t *)result);
1470 return result;
1471 }
1472
psvec4_one(struct vec4 * result)1473 MATHC_INLINE struct vec4 *psvec4_one(struct vec4 *result)
1474 {
1475 vec4_one((mfloat_t *)result);
1476 return result;
1477 }
1478
psvec4_add(struct vec4 * result,struct vec4 * a,struct vec4 * b)1479 MATHC_INLINE struct vec4 *psvec4_add(struct vec4 *result, struct vec4 *a, struct vec4 *b)
1480 {
1481 vec4_add((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1482 return result;
1483 }
1484
psvec4_subtract(struct vec4 * result,struct vec4 * a,struct vec4 * b)1485 MATHC_INLINE struct vec4 *psvec4_subtract(struct vec4 *result, struct vec4 *a, struct vec4 *b)
1486 {
1487 vec4_subtract((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1488 return result;
1489 }
1490
psvec4_scale(struct vec4 * result,struct vec4 * a,mfloat_t scalar)1491 MATHC_INLINE struct vec4 *psvec4_scale(struct vec4 *result, struct vec4 *a, mfloat_t scalar)
1492 {
1493 vec4_scale((mfloat_t *)result, (mfloat_t *)a, scalar);
1494 return result;
1495 }
1496
psvec4_multiply(struct vec4 * result,struct vec4 * a,struct vec4 * b)1497 MATHC_INLINE struct vec4 *psvec4_multiply(struct vec4 *result, struct vec4 *a, struct vec4 *b)
1498 {
1499 vec4_multiply((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1500 return result;
1501 }
1502
psvec4_multiply_mat4(struct vec4 * result,struct vec4 * a,struct mat4 * m)1503 MATHC_INLINE struct vec4 *psvec4_multiply_mat4(struct vec4 *result, struct vec4 *a, struct mat4 *m)
1504 {
1505 vec4_multiply_mat4((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)m);
1506 return result;
1507 }
1508
psvec4_divide(struct vec4 * result,struct vec4 * a,struct vec4 * b)1509 MATHC_INLINE struct vec4 *psvec4_divide(struct vec4 *result, struct vec4 *a, struct vec4 *b)
1510 {
1511 vec4_divide((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1512 return result;
1513 }
1514
psvec4_snap(struct vec4 * result,struct vec4 * a,struct vec4 * b)1515 MATHC_INLINE struct vec4 *psvec4_snap(struct vec4 *result, struct vec4 *a, struct vec4 *b)
1516 {
1517 vec4_snap((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1518 return result;
1519 }
1520
psvec4_negative(struct vec4 * result,struct vec4 * a)1521 MATHC_INLINE struct vec4 *psvec4_negative(struct vec4 *result, struct vec4 *a)
1522 {
1523 vec4_negative((mfloat_t *)result, (mfloat_t *)a);
1524 return result;
1525 }
1526
psvec4_inverse(struct vec4 * result,struct vec4 * a)1527 MATHC_INLINE struct vec4 *psvec4_inverse(struct vec4 *result, struct vec4 *a)
1528 {
1529 vec4_inverse((mfloat_t *)result, (mfloat_t *)a);
1530 return result;
1531 }
1532
psvec4_abs(struct vec4 * result,struct vec4 * a)1533 MATHC_INLINE struct vec4 *psvec4_abs(struct vec4 *result, struct vec4 *a)
1534 {
1535 vec4_abs((mfloat_t *)result, (mfloat_t *)a);
1536 return result;
1537 }
1538
psvec4_floor(struct vec4 * result,struct vec4 * a)1539 MATHC_INLINE struct vec4 *psvec4_floor(struct vec4 *result, struct vec4 *a)
1540 {
1541 vec4_floor((mfloat_t *)result, (mfloat_t *)a);
1542 return result;
1543 }
1544
psvec4_ceil(struct vec4 * result,struct vec4 * a)1545 MATHC_INLINE struct vec4 *psvec4_ceil(struct vec4 *result, struct vec4 *a)
1546 {
1547 vec4_ceil((mfloat_t *)result, (mfloat_t *)a);
1548 return result;
1549 }
1550
psvec4_round(struct vec4 * result,struct vec4 * a)1551 MATHC_INLINE struct vec4 *psvec4_round(struct vec4 *result, struct vec4 *a)
1552 {
1553 vec4_round((mfloat_t *)result, (mfloat_t *)a);
1554 return result;
1555 }
1556
psvec4_max(struct vec4 * result,struct vec4 * a,struct vec4 * b)1557 MATHC_INLINE struct vec4 *psvec4_max(struct vec4 *result, struct vec4 *a, struct vec4 *b)
1558 {
1559 vec4_max((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1560 return result;
1561 }
1562
psvec4_min(struct vec4 * result,struct vec4 * a,struct vec4 * b)1563 MATHC_INLINE struct vec4 *psvec4_min(struct vec4 *result, struct vec4 *a, struct vec4 *b)
1564 {
1565 vec4_min((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1566 return result;
1567 }
1568
psvec4_clamp(struct vec4 * result,struct vec4 * a,struct vec4 * lower,struct vec4 * higher)1569 MATHC_INLINE struct vec4 *psvec4_clamp(struct vec4 *result, struct vec4 *a, struct vec4 *lower, struct vec4 *higher)
1570 {
1571 vec4_clamp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)lower, (mfloat_t *)higher);
1572 return result;
1573 }
1574
psvec4_normalize(struct vec4 * result,struct vec4 * a)1575 MATHC_INLINE struct vec4 *psvec4_normalize(struct vec4 *result, struct vec4 *a)
1576 {
1577 vec4_normalize((mfloat_t *)result, (mfloat_t *)a);
1578 return result;
1579 }
1580
psvec4_lerp(struct vec4 * result,struct vec4 * a,struct vec4 * b,mfloat_t p)1581 MATHC_INLINE struct vec4 *psvec4_lerp(struct vec4 *result, struct vec4 *a, struct vec4 *b, mfloat_t p)
1582 {
1583 vec4_lerp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, p);
1584 return result;
1585 }
1586
1587 /* Vector 4D */
psvec4i_is_zero(struct vec4i * a)1588 MATHC_INLINE bool psvec4i_is_zero(struct vec4i *a)
1589 {
1590 return vec4i_is_zero((mint_t *)a);
1591 }
1592
psvec4i_is_equal(struct vec4i * a,struct vec4i * b)1593 MATHC_INLINE bool psvec4i_is_equal(struct vec4i *a, struct vec4i *b)
1594 {
1595 return vec4i_is_equal((mint_t *)a, (mint_t *)b);
1596 }
1597
psvec4i(struct vec4i * result,mint_t x,mint_t y,mint_t z,mint_t w)1598 MATHC_INLINE struct vec4i *psvec4i(struct vec4i *result, mint_t x, mint_t y, mint_t z, mint_t w)
1599 {
1600 vec4i((mint_t *)result, x, y, z, w);
1601 return result;
1602 }
1603
psvec4i_assign(struct vec4i * result,struct vec4i * a)1604 MATHC_INLINE struct vec4i *psvec4i_assign(struct vec4i *result, struct vec4i *a)
1605 {
1606 vec4i_assign((mint_t *)result, (mint_t *)a);
1607 return result;
1608 }
1609
psvec4i_assign_vec4(struct vec4i * result,struct vec4 * a)1610 MATHC_INLINE struct vec4i *psvec4i_assign_vec4(struct vec4i *result, struct vec4 *a)
1611 {
1612 vec4i_assign_vec4((mint_t *)result, (mfloat_t *)a);
1613 return result;
1614 }
1615
psvec4i_zero(struct vec4i * result)1616 MATHC_INLINE struct vec4i *psvec4i_zero(struct vec4i *result)
1617 {
1618 vec4i_zero((mint_t *)result);
1619 return result;
1620 }
1621
psvec4i_one(struct vec4i * result)1622 MATHC_INLINE struct vec4i *psvec4i_one(struct vec4i *result)
1623 {
1624 vec4i_one((mint_t *)result);
1625 return result;
1626 }
1627
psvec4i_add(struct vec4i * result,struct vec4i * a,struct vec4i * b)1628 MATHC_INLINE struct vec4i *psvec4i_add(struct vec4i *result, struct vec4i *a, struct vec4i *b)
1629 {
1630 vec4i_add((mint_t *)result, (mint_t *)a, (mint_t *)b);
1631 return result;
1632 }
1633
psvec4i_subtract(struct vec4i * result,struct vec4i * a,struct vec4i * b)1634 MATHC_INLINE struct vec4i *psvec4i_subtract(struct vec4i *result, struct vec4i *a, struct vec4i *b)
1635 {
1636 vec4i_subtract((mint_t *)result, (mint_t *)a, (mint_t *)b);
1637 return result;
1638 }
1639
psvec4i_scale(struct vec4i * result,struct vec4i * a,mfloat_t scalar)1640 MATHC_INLINE struct vec4i *psvec4i_scale(struct vec4i *result, struct vec4i *a, mfloat_t scalar)
1641 {
1642 vec4i_scale((mint_t *)result, (mint_t *)a, scalar);
1643 return result;
1644 }
1645
psvec4i_multiply(struct vec4i * result,struct vec4i * a,struct vec4i * b)1646 MATHC_INLINE struct vec4i *psvec4i_multiply(struct vec4i *result, struct vec4i *a, struct vec4i *b)
1647 {
1648 vec4i_multiply((mint_t *)result, (mint_t *)a, (mint_t *)b);
1649 return result;
1650 }
1651
psvec4i_multiply_mat4(struct vec4i * result,struct vec4i * a,struct mat4 * m)1652 MATHC_INLINE struct vec4i *psvec4i_multiply_mat4(struct vec4i *result, struct vec4i *a, struct mat4 *m)
1653 {
1654 vec4i_multiply_mat4((mint_t *)result, (mint_t *)a, (mfloat_t *)m);
1655 return result;
1656 }
1657
psvec4i_divide(struct vec4i * result,struct vec4i * a,struct vec4i * b)1658 MATHC_INLINE struct vec4i *psvec4i_divide(struct vec4i *result, struct vec4i *a, struct vec4i *b)
1659 {
1660 vec4i_divide((mint_t *)result, (mint_t *)a, (mint_t *)b);
1661 return result;
1662 }
1663
psvec4i_snap(struct vec4i * result,struct vec4i * a,struct vec4i * b)1664 MATHC_INLINE struct vec4i *psvec4i_snap(struct vec4i *result, struct vec4i *a, struct vec4i *b)
1665 {
1666 vec4i_snap((mint_t *)result, (mint_t *)a, (mint_t *)b);
1667 return result;
1668 }
1669
psvec4i_negative(struct vec4i * result,struct vec4i * a)1670 MATHC_INLINE struct vec4i *psvec4i_negative(struct vec4i *result, struct vec4i *a)
1671 {
1672 vec4i_negative((mint_t *)result, (mint_t *)a);
1673 return result;
1674 }
1675
psvec4i_inverse(struct vec4i * result,struct vec4i * a)1676 MATHC_INLINE struct vec4i *psvec4i_inverse(struct vec4i *result, struct vec4i *a)
1677 {
1678 vec4i_inverse((mint_t *)result, (mint_t *)a);
1679 return result;
1680 }
1681
psvec4i_abs(struct vec4i * result,struct vec4i * a)1682 MATHC_INLINE struct vec4i *psvec4i_abs(struct vec4i *result, struct vec4i *a)
1683 {
1684 vec4i_abs((mint_t *)result, (mint_t *)a);
1685 return result;
1686 }
1687
psvec4i_floor(struct vec4i * result,struct vec4 * a)1688 MATHC_INLINE struct vec4i *psvec4i_floor(struct vec4i *result, struct vec4 *a)
1689 {
1690 vec4i_floor((mint_t *)result, (mfloat_t *)a);
1691 return result;
1692 }
1693
psvec4i_ceil(struct vec4i * result,struct vec4 * a)1694 MATHC_INLINE struct vec4i *psvec4i_ceil(struct vec4i *result, struct vec4 *a)
1695 {
1696 vec4i_ceil((mint_t *)result, (mfloat_t *)a);
1697 return result;
1698 }
1699
psvec4i_round(struct vec4i * result,struct vec4 * a)1700 MATHC_INLINE struct vec4i *psvec4i_round(struct vec4i *result, struct vec4 *a)
1701 {
1702 vec4i_round((mint_t *)result, (mfloat_t *)a);
1703 return result;
1704 }
1705
psvec4i_max(struct vec4i * result,struct vec4i * a,struct vec4i * b)1706 MATHC_INLINE struct vec4i *psvec4i_max(struct vec4i *result, struct vec4i *a, struct vec4i *b)
1707 {
1708 vec4i_max((mint_t *)result, (mint_t *)a, (mint_t *)b);
1709 return result;
1710 }
1711
psvec4i_min(struct vec4i * result,struct vec4i * a,struct vec4i * b)1712 MATHC_INLINE struct vec4i *psvec4i_min(struct vec4i *result, struct vec4i *a, struct vec4i *b)
1713 {
1714 vec4i_min((mint_t *)result, (mint_t *)a, (mint_t *)b);
1715 return result;
1716 }
1717
psvec4i_clamp(struct vec4i * result,struct vec4i * a,struct vec4i * lower,struct vec4i * higher)1718 MATHC_INLINE struct vec4i *psvec4i_clamp(struct vec4i *result, struct vec4i *a, struct vec4i *lower, struct vec4i *higher)
1719 {
1720 vec4i_clamp((mint_t *)result, (mint_t *)a, (mint_t *)lower, (mint_t *)higher);
1721 return result;
1722 }
1723
psvec4i_normalize(struct vec4i * result,struct vec4i * a)1724 MATHC_INLINE struct vec4i *psvec4i_normalize(struct vec4i *result, struct vec4i *a)
1725 {
1726 vec4i_normalize((mint_t *)result, (mint_t *)a);
1727 return result;
1728 }
1729
psvec4i_lerp(struct vec4i * result,struct vec4i * a,struct vec4i * b,mfloat_t p)1730 MATHC_INLINE struct vec4i *psvec4i_lerp(struct vec4i *result, struct vec4i *a, struct vec4i *b, mfloat_t p)
1731 {
1732 vec4i_lerp((mint_t *)result, (mint_t *)a, (mint_t *)b, p);
1733 return result;
1734 }
1735
1736 /* Quaternion */
psquat_is_zero(struct quat * a)1737 MATHC_INLINE bool psquat_is_zero(struct quat *a)
1738 {
1739 return quat_is_zero((mfloat_t *)a);
1740 }
1741
psquat_is_near_zero(struct quat * a,mfloat_t epsilon)1742 MATHC_INLINE bool psquat_is_near_zero(struct quat *a, mfloat_t epsilon)
1743 {
1744 return quat_is_near_zero((mfloat_t *)a, epsilon);
1745 }
1746
psquat_is_equal(struct quat * a,struct quat * b)1747 MATHC_INLINE bool psquat_is_equal(struct quat *a, struct quat *b)
1748 {
1749 return quat_is_equal((mfloat_t *)a, (mfloat_t *)b);
1750 }
1751
psquat_is_nearly_equal(struct quat * a,struct quat * b,mfloat_t epsilon)1752 MATHC_INLINE bool psquat_is_nearly_equal(struct quat *a, struct quat *b, mfloat_t epsilon)
1753 {
1754 return quat_is_nearly_equal((mfloat_t *)a, (mfloat_t *)b, epsilon);
1755 }
1756
psquat(struct quat * result,mfloat_t x,mfloat_t y,mfloat_t z,mfloat_t w)1757 MATHC_INLINE struct quat *psquat(struct quat *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
1758 {
1759 quat((mfloat_t *)result, x, y, z, w);
1760 return result;
1761 }
1762
psquat_assign(struct quat * result,struct quat * a)1763 MATHC_INLINE struct quat *psquat_assign(struct quat *result, struct quat *a)
1764 {
1765 quat_assign((mfloat_t *)result, (mfloat_t *)a);
1766 return result;
1767 }
1768
psquat_zero(struct quat * result)1769 MATHC_INLINE struct quat *psquat_zero(struct quat *result)
1770 {
1771 quat_zero((mfloat_t *)result);
1772 return result;
1773 }
1774
psquat_null(struct quat * result)1775 MATHC_INLINE struct quat *psquat_null(struct quat *result)
1776 {
1777 quat_null((mfloat_t *)result);
1778 return result;
1779 }
1780
psquat_scale(struct quat * result,struct quat * a,mfloat_t scalar)1781 MATHC_INLINE struct quat *psquat_scale(struct quat *result, struct quat *a, mfloat_t scalar)
1782 {
1783 quat_scale((mfloat_t *)result, (mfloat_t *)a, scalar);
1784 return result;
1785 }
1786
psquat_multiply(struct quat * result,struct quat * a,struct quat * b)1787 MATHC_INLINE struct quat *psquat_multiply(struct quat *result, struct quat *a, struct quat *b)
1788 {
1789 quat_multiply((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1790 return result;
1791 }
1792
psquat_divide(struct quat * result,struct quat * a,struct quat * b)1793 MATHC_INLINE struct quat *psquat_divide(struct quat *result, struct quat *a, struct quat *b)
1794 {
1795 quat_divide((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1796 return result;
1797 }
1798
psquat_negative(struct quat * result,struct quat * a)1799 MATHC_INLINE struct quat *psquat_negative(struct quat *result, struct quat *a)
1800 {
1801 quat_negative((mfloat_t *)result, (mfloat_t *)a);
1802 return result;
1803 }
1804
psquat_conjugate(struct quat * result,struct quat * a)1805 MATHC_INLINE struct quat *psquat_conjugate(struct quat *result, struct quat *a)
1806 {
1807 quat_conjugate((mfloat_t *)result, (mfloat_t *)a);
1808 return result;
1809 }
1810
psquat_inverse(struct quat * result,struct quat * a)1811 MATHC_INLINE struct quat *psquat_inverse(struct quat *result, struct quat *a)
1812 {
1813 quat_inverse((mfloat_t *)result, (mfloat_t *)a);
1814 return result;
1815 }
1816
psquat_normalize(struct quat * result,struct quat * a)1817 MATHC_INLINE struct quat *psquat_normalize(struct quat *result, struct quat *a)
1818 {
1819 quat_normalize((mfloat_t *)result, (mfloat_t *)a);
1820 return result;
1821 }
1822
psquat_power(struct quat * result,struct quat * a,mfloat_t exponent)1823 MATHC_INLINE struct quat *psquat_power(struct quat *result, struct quat *a, mfloat_t exponent)
1824 {
1825 quat_power((mfloat_t *)result, (mfloat_t *)a, exponent);
1826 return result;
1827 }
1828
psquat_from_axis_angle(struct quat * result,struct vec3 * a,mfloat_t angle)1829 MATHC_INLINE struct quat *psquat_from_axis_angle(struct quat *result, struct vec3 *a, mfloat_t angle)
1830 {
1831 quat_from_axis_angle((mfloat_t *)result, (mfloat_t *)a, angle);
1832 return result;
1833 }
1834
psquat_from_vec3(struct quat * result,struct vec3 * a,struct vec3 * b)1835 MATHC_INLINE struct quat *psquat_from_vec3(struct quat *result, struct vec3 *a, struct vec3 *b)
1836 {
1837 quat_from_vec3((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1838 return result;
1839 }
1840
psquat_from_mat4(struct quat * result,struct mat4 * a)1841 MATHC_INLINE struct quat *psquat_from_mat4(struct quat *result, struct mat4 *a)
1842 {
1843 quat_from_mat4((mfloat_t *)result, (mfloat_t *)a);
1844 return result;
1845 }
1846
psquat_from_yaw_pitch_roll(struct quat * result,mfloat_t yaw,mfloat_t pitch,mfloat_t roll)1847 MATHC_INLINE struct quat *psquat_from_yaw_pitch_roll(struct quat *result, mfloat_t yaw, mfloat_t pitch, mfloat_t roll)
1848 {
1849 quat_from_yaw_pitch_roll((mfloat_t *)result, yaw, pitch, roll);
1850 return result;
1851 }
1852
psquat_lerp(struct quat * result,struct quat * a,struct quat * b,mfloat_t p)1853 MATHC_INLINE struct quat *psquat_lerp(struct quat *result, struct quat *a, struct quat *b, mfloat_t p)
1854 {
1855 quat_lerp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, p);
1856 return result;
1857 }
1858
psquat_slerp(struct quat * result,struct quat * a,struct quat * b,mfloat_t p)1859 MATHC_INLINE struct quat *psquat_slerp(struct quat *result, struct quat *a, struct quat *b, mfloat_t p)
1860 {
1861 quat_slerp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, p);
1862 return result;
1863 }
1864
psquat_dot(struct quat * a,struct quat * b)1865 MATHC_INLINE mfloat_t psquat_dot(struct quat *a, struct quat *b)
1866 {
1867 return quat_dot((mfloat_t *)a, (mfloat_t *)b);
1868 }
1869
psquat_angle(struct quat * a,struct quat * b)1870 MATHC_INLINE mfloat_t psquat_angle(struct quat *a, struct quat *b)
1871 {
1872 return quat_angle((mfloat_t *)a, (mfloat_t *)b);
1873 }
1874
psquat_length(struct quat * a)1875 MATHC_INLINE mfloat_t psquat_length(struct quat *a)
1876 {
1877 return quat_length((mfloat_t *)a);
1878 }
1879
psquat_length_squared(struct quat * a)1880 MATHC_INLINE mfloat_t psquat_length_squared(struct quat *a)
1881 {
1882 return quat_length_squared((mfloat_t *)a);
1883 }
1884
1885 /* Matrix 2x2 */
psmat2(struct mat2 * result,mfloat_t m11,mfloat_t m12,mfloat_t m21,mfloat_t m22)1886 MATHC_INLINE struct mat2 *psmat2(struct mat2 *result,
1887 mfloat_t m11, mfloat_t m12,
1888 mfloat_t m21, mfloat_t m22)
1889 {
1890 mat2((mfloat_t *)result,
1891 m11, m12,
1892 m21, m22);
1893 return result;
1894 }
1895
psmat2_zero(struct mat2 * result)1896 MATHC_INLINE struct mat2 *psmat2_zero(struct mat2 *result)
1897 {
1898 mat2_zero((mfloat_t *)result);
1899 return result;
1900 }
1901
psmat2_identity(struct mat2 * result)1902 MATHC_INLINE struct mat2 *psmat2_identity(struct mat2 *result)
1903 {
1904 mat2_identity((mfloat_t *)result);
1905 return result;
1906 }
1907
psmat2_determinant(struct mat2 * m)1908 MATHC_INLINE mfloat_t psmat2_determinant(struct mat2 *m)
1909 {
1910 return mat2_determinant((mfloat_t *)m);
1911 }
1912
psmat2_assign(struct mat2 * result,struct mat2 * m)1913 MATHC_INLINE struct mat2 *psmat2_assign(struct mat2 *result, struct mat2 *m)
1914 {
1915 mat2_assign((mfloat_t *)result, (mfloat_t *)m);
1916 return result;
1917 }
1918
psmat2_assign_mat3(struct mat2 * result,struct mat3 * m)1919 MATHC_INLINE struct mat2 *psmat2_assign_mat3(struct mat2 *result, struct mat3 *m)
1920 {
1921 mat2_assign_mat3((mfloat_t *)result, (mfloat_t *)m);
1922 return result;
1923 }
1924
psmat2_assign_mat4(struct mat2 * result,struct mat4 * m)1925 MATHC_INLINE struct mat2 *psmat2_assign_mat4(struct mat2 *result, struct mat4 *m)
1926 {
1927 mat2_assign_mat4((mfloat_t *)result, (mfloat_t *)m);
1928 return result;
1929 }
1930
psmat2_transpose(struct mat2 * result,struct mat2 * m)1931 MATHC_INLINE struct mat2 *psmat2_transpose(struct mat2 *result, struct mat2 *m)
1932 {
1933 mat2_transpose((mfloat_t *)result, (mfloat_t *)m);
1934 return result;
1935 }
1936
psmat2_cofactor(struct mat2 * result,struct mat2 * m)1937 MATHC_INLINE struct mat2 *psmat2_cofactor(struct mat2 *result, struct mat2 *m)
1938 {
1939 mat2_cofactor((mfloat_t *)result, (mfloat_t *)m);
1940 return result;
1941 }
1942
psmat2_inverse(struct mat2 * result,struct mat2 * m)1943 MATHC_INLINE struct mat2 *psmat2_inverse(struct mat2 *result, struct mat2 *m)
1944 {
1945 mat2_inverse((mfloat_t *)result, (mfloat_t *)m);
1946 return result;
1947 }
1948
psmat2_rotation(struct mat2 * result,mfloat_t angle)1949 MATHC_INLINE struct mat2 *psmat2_rotation(struct mat2 *result, mfloat_t angle)
1950 {
1951 mat2_rotation((mfloat_t *)result, angle);
1952 return result;
1953 }
1954
psmat2_scaling(struct mat2 * result,struct mat2 * v)1955 MATHC_INLINE struct mat2 *psmat2_scaling(struct mat2 *result, struct mat2 *v)
1956 {
1957 mat2_scaling((mfloat_t *)result, (mfloat_t *)v);
1958 return result;
1959 }
1960
psmat2_negative(struct mat2 * result,struct mat2 * m)1961 MATHC_INLINE struct mat2 *psmat2_negative(struct mat2 *result, struct mat2 *m)
1962 {
1963 mat2_negative((mfloat_t *)result, (mfloat_t *)m);
1964 return result;
1965 }
1966
psmat2_scale(struct mat2 * result,struct mat2 * m,mfloat_t s)1967 MATHC_INLINE struct mat2 *psmat2_scale(struct mat2 *result, struct mat2 *m, mfloat_t s)
1968 {
1969 mat2_scale((mfloat_t *)result, (mfloat_t *)m, s);
1970 return result;
1971 }
1972
psmat2_multiply(struct mat2 * result,struct mat2 * a,struct mat2 * b)1973 MATHC_INLINE struct mat2 *psmat2_multiply(struct mat2 *result, struct mat2 *a, struct mat2 *b)
1974 {
1975 mat2_multiply((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
1976 return result;
1977 }
1978
psmat2_lerp(struct mat2 * result,struct mat2 * a,struct mat2 * b,mfloat_t p)1979 MATHC_INLINE struct mat2 *psmat2_lerp(struct mat2 *result, struct mat2 *a, struct mat2 *b, mfloat_t p)
1980 {
1981 mat2_lerp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, p);
1982 return result;
1983 }
1984
1985 /* Matrix 3x3 */
psmat3(struct mat3 * result,mfloat_t m11,mfloat_t m12,mfloat_t m13,mfloat_t m21,mfloat_t m22,mfloat_t m23,mfloat_t m31,mfloat_t m32,mfloat_t m33)1986 MATHC_INLINE struct mat3 *psmat3(struct mat3 *result,
1987 mfloat_t m11, mfloat_t m12, mfloat_t m13,
1988 mfloat_t m21, mfloat_t m22, mfloat_t m23,
1989 mfloat_t m31, mfloat_t m32, mfloat_t m33)
1990 {
1991 mat3((mfloat_t *)result,
1992 m11, m12, m13,
1993 m21, m22, m23,
1994 m31, m32, m33);
1995 return result;
1996 }
1997
psmat3_zero(struct mat3 * result)1998 MATHC_INLINE struct mat3 *psmat3_zero(struct mat3 *result)
1999 {
2000 mat3_zero((mfloat_t *)result);
2001 return result;
2002 }
2003
psmat3_identity(struct mat3 * result)2004 MATHC_INLINE struct mat3 *psmat3_identity(struct mat3 *result)
2005 {
2006 mat3_identity((mfloat_t *)result);
2007 return result;
2008 }
2009
psmat3_determinant(struct mat3 * m)2010 MATHC_INLINE mfloat_t psmat3_determinant(struct mat3 *m)
2011 {
2012 return mat3_determinant((mfloat_t *)m);
2013 }
2014
psmat3_assign(struct mat3 * result,struct mat3 * m)2015 MATHC_INLINE struct mat3 *psmat3_assign(struct mat3 *result, struct mat3 *m)
2016 {
2017 mat3_assign((mfloat_t *)result, (mfloat_t *)m);
2018 return result;
2019 }
2020
psmat3_assign_mat2(struct mat3 * result,struct mat2 * m)2021 MATHC_INLINE struct mat3 *psmat3_assign_mat2(struct mat3 *result, struct mat2 *m)
2022 {
2023 mat3_assign_mat2((mfloat_t *)result, (mfloat_t *)m);
2024 return result;
2025 }
2026
psmat3_assign_mat4(struct mat3 * result,struct mat4 * m)2027 MATHC_INLINE struct mat3 *psmat3_assign_mat4(struct mat3 *result, struct mat4 *m)
2028 {
2029 mat3_assign_mat4((mfloat_t *)result, (mfloat_t *)m);
2030 return result;
2031 }
2032
psmat3_transpose(struct mat3 * result,struct mat3 * m)2033 MATHC_INLINE struct mat3 *psmat3_transpose(struct mat3 *result, struct mat3 *m)
2034 {
2035 mat3_transpose((mfloat_t *)result, (mfloat_t *)m);
2036 return result;
2037 }
2038
psmat3_cofactor(struct mat3 * result,struct mat3 * m)2039 MATHC_INLINE struct mat3 *psmat3_cofactor(struct mat3 *result, struct mat3 *m)
2040 {
2041 mat3_cofactor((mfloat_t *)result, (mfloat_t *)m);
2042 return result;
2043 }
2044
psmat3_adjugate(struct mat3 * result,struct mat3 * m)2045 MATHC_INLINE struct mat3 *psmat3_adjugate(struct mat3 *result, struct mat3 *m)
2046 {
2047 mat3_adjugate((mfloat_t *)result, (mfloat_t *)m);
2048 return result;
2049 }
2050
psmat3_inverse(struct mat3 * result,struct mat3 * m)2051 MATHC_INLINE struct mat3 *psmat3_inverse(struct mat3 *result, struct mat3 *m)
2052 {
2053 mat3_inverse((mfloat_t *)result, (mfloat_t *)m);
2054 return result;
2055 }
2056
psmat3_rotation_x(struct mat3 * result,mfloat_t angle)2057 MATHC_INLINE struct mat3 *psmat3_rotation_x(struct mat3 *result, mfloat_t angle)
2058 {
2059 mat3_rotation_x((mfloat_t *)result, angle);
2060 return result;
2061 }
2062
psmat3_rotation_y(struct mat3 * result,mfloat_t angle)2063 MATHC_INLINE struct mat3 *psmat3_rotation_y(struct mat3 *result, mfloat_t angle)
2064 {
2065 mat3_rotation_y((mfloat_t *)result, angle);
2066 return result;
2067 }
2068
psmat3_rotation_z(struct mat3 * result,mfloat_t angle)2069 MATHC_INLINE struct mat3 *psmat3_rotation_z(struct mat3 *result, mfloat_t angle)
2070 {
2071 mat3_rotation_z((mfloat_t *)result, angle);
2072 return result;
2073 }
2074
psmat3_rotation_axis(struct mat3 * result,struct vec3 * a,mfloat_t angle)2075 MATHC_INLINE struct mat3 *psmat3_rotation_axis(struct mat3 *result, struct vec3 *a, mfloat_t angle)
2076 {
2077 mat3_rotation_axis((mfloat_t *)result, (mfloat_t *)a, angle);
2078 return result;
2079 }
2080
psmat3_rotation_quaternion(struct mat3 * result,struct quat * q)2081 MATHC_INLINE struct mat3 *psmat3_rotation_quaternion(struct mat3 *result, struct quat *q)
2082 {
2083 mat3_rotation_quaternion((mfloat_t *)result, (mfloat_t *)q);
2084 return result;
2085 }
2086
psmat3_scaling(struct mat3 * result,struct mat3 * v)2087 MATHC_INLINE struct mat3 *psmat3_scaling(struct mat3 *result, struct mat3 *v)
2088 {
2089 mat3_scaling((mfloat_t *)result, (mfloat_t *)v);
2090 return result;
2091 }
2092
psmat3_negative(struct mat3 * result,struct mat3 * m)2093 MATHC_INLINE struct mat3 *psmat3_negative(struct mat3 *result, struct mat3 *m)
2094 {
2095 mat3_negative((mfloat_t *)result, (mfloat_t *)m);
2096 return result;
2097 }
2098
psmat3_scale(struct mat3 * result,struct mat3 * m,mfloat_t s)2099 MATHC_INLINE struct mat3 *psmat3_scale(struct mat3 *result, struct mat3 *m, mfloat_t s)
2100 {
2101 mat3_scale((mfloat_t *)result, (mfloat_t *)m, s);
2102 return result;
2103 }
2104
psmat3_multiply(struct mat3 * result,struct mat3 * a,struct mat3 * b)2105 MATHC_INLINE struct mat3 *psmat3_multiply(struct mat3 *result, struct mat3 *a, struct mat3 *b)
2106 {
2107 mat3_multiply((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
2108 return result;
2109 }
2110
psmat3_lerp(struct mat3 * result,struct mat3 * a,struct mat3 * b,mfloat_t p)2111 MATHC_INLINE struct mat3 *psmat3_lerp(struct mat3 *result, struct mat3 *a, struct mat3 *b, mfloat_t p)
2112 {
2113 mat3_lerp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, p);
2114 return result;
2115 }
2116
2117 /* Matrix 4x4 */
psmat4(struct mat4 * result,mfloat_t m11,mfloat_t m12,mfloat_t m13,mfloat_t m14,mfloat_t m21,mfloat_t m22,mfloat_t m23,mfloat_t m24,mfloat_t m31,mfloat_t m32,mfloat_t m33,mfloat_t m34,mfloat_t m41,mfloat_t m42,mfloat_t m43,mfloat_t m44)2118 MATHC_INLINE struct mat4 *psmat4(struct mat4 *result,
2119 mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14,
2120 mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24,
2121 mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34,
2122 mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44)
2123 {
2124 mat4((mfloat_t *)result,
2125 m11, m12, m13, m14,
2126 m21, m22, m23, m24,
2127 m31, m32, m33, m34,
2128 m41, m42, m43, m44);
2129 return result;
2130 }
2131
psmat4_zero(struct mat4 * result)2132 MATHC_INLINE struct mat4 *psmat4_zero(struct mat4 *result)
2133 {
2134 mat4_zero((mfloat_t *)result);
2135 return result;
2136 }
2137
psmat4_identity(struct mat4 * result)2138 MATHC_INLINE struct mat4 *psmat4_identity(struct mat4 *result)
2139 {
2140 mat4_identity((mfloat_t *)result);
2141 return result;
2142 }
2143
psmat4_determinant(struct mat4 * m)2144 MATHC_INLINE mfloat_t psmat4_determinant(struct mat4 *m)
2145 {
2146 return mat4_determinant((mfloat_t *)m);
2147 }
2148
psmat4_assign(struct mat4 * result,struct mat4 * m)2149 MATHC_INLINE struct mat4 *psmat4_assign(struct mat4 *result, struct mat4 *m)
2150 {
2151 mat4_assign((mfloat_t *)result, (mfloat_t *)m);
2152 return result;
2153 }
2154
psmat4_assign_mat2(struct mat4 * result,struct mat2 * m)2155 MATHC_INLINE struct mat4 *psmat4_assign_mat2(struct mat4 *result, struct mat2 *m)
2156 {
2157 mat4_assign_mat2((mfloat_t *)result, (mfloat_t *)m);
2158 return result;
2159 }
2160
psmat4_assign_mat3(struct mat4 * result,struct mat3 * m)2161 MATHC_INLINE struct mat4 *psmat4_assign_mat3(struct mat4 *result, struct mat3 *m)
2162 {
2163 mat4_assign_mat3((mfloat_t *)result, (mfloat_t *)m);
2164 return result;
2165 }
2166
psmat4_transpose(struct mat4 * result,struct mat4 * m)2167 MATHC_INLINE struct mat4 *psmat4_transpose(struct mat4 *result, struct mat4 *m)
2168 {
2169 mat4_transpose((mfloat_t *)result, (mfloat_t *)m);
2170 return result;
2171 }
2172
psmat4_adjugate(struct mat4 * result,struct mat4 * m)2173 MATHC_INLINE struct mat4 *psmat4_adjugate(struct mat4 *result, struct mat4 *m)
2174 {
2175 mat4_adjugate((mfloat_t *)result, (mfloat_t *)m);
2176 return result;
2177 }
2178
psmat4_inverse(struct mat4 * result,struct mat4 * m)2179 MATHC_INLINE struct mat4 *psmat4_inverse(struct mat4 *result, struct mat4 *m)
2180 {
2181 mat4_inverse((mfloat_t *)result, (mfloat_t *)m);
2182 return result;
2183 }
2184
psmat4_ortho(struct mat4 * result,mfloat_t l,mfloat_t r,mfloat_t b,mfloat_t t,mfloat_t n,mfloat_t f)2185 MATHC_INLINE struct mat4 *psmat4_ortho(struct mat4 *result, mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f)
2186 {
2187 mat4_ortho((mfloat_t *)result, l, r, b, t, n, f);
2188 return result;
2189 }
2190
psmat4_perspective(struct mat4 * result,mfloat_t fov_y,mfloat_t aspect,mfloat_t n,mfloat_t f)2191 MATHC_INLINE struct mat4 *psmat4_perspective(struct mat4 *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f)
2192 {
2193 mat4_perspective((mfloat_t *)result, fov_y, aspect, n, f);
2194 return result;
2195 }
2196
psmat4_perspective_fov(struct mat4 * result,mfloat_t fov,mfloat_t w,mfloat_t h,mfloat_t n,mfloat_t f)2197 MATHC_INLINE struct mat4 *psmat4_perspective_fov(struct mat4 *result, mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f)
2198 {
2199 mat4_perspective_fov((mfloat_t *)result, fov, w, h, n, f);
2200 return result;
2201 }
2202
psmat4_perspective_infinite(struct mat4 * result,mfloat_t fov_y,mfloat_t aspect,mfloat_t n)2203 MATHC_INLINE struct mat4 *psmat4_perspective_infinite(struct mat4 *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n)
2204 {
2205 mat4_perspective_infinite((mfloat_t *)result, fov_y, aspect, n);
2206 return result;
2207 }
2208
psmat4_rotation_x(struct mat4 * result,mfloat_t angle)2209 MATHC_INLINE struct mat4 *psmat4_rotation_x(struct mat4 *result, mfloat_t angle)
2210 {
2211 mat4_rotation_x((mfloat_t *)result, angle);
2212 return result;
2213 }
2214
psmat4_rotation_y(struct mat4 * result,mfloat_t angle)2215 MATHC_INLINE struct mat4 *psmat4_rotation_y(struct mat4 *result, mfloat_t angle)
2216 {
2217 mat4_rotation_y((mfloat_t *)result, angle);
2218 return result;
2219 }
2220
psmat4_rotation_z(struct mat4 * result,mfloat_t angle)2221 MATHC_INLINE struct mat4 *psmat4_rotation_z(struct mat4 *result, mfloat_t angle)
2222 {
2223 mat4_rotation_z((mfloat_t *)result, angle);
2224 return result;
2225 }
2226
psmat4_rotation_axis(struct mat4 * result,struct mat4 * a,mfloat_t angle)2227 MATHC_INLINE struct mat4 *psmat4_rotation_axis(struct mat4 *result, struct mat4 *a, mfloat_t angle)
2228 {
2229 mat4_rotation_axis((mfloat_t *)result, (mfloat_t *)a, angle);
2230 return result;
2231 }
2232
psmat4_rotation_quaternion(struct mat4 * result,struct mat4 * q)2233 MATHC_INLINE struct mat4 *psmat4_rotation_quaternion(struct mat4 *result, struct mat4 *q)
2234 {
2235 mat4_rotation_quaternion((mfloat_t *)result, (mfloat_t *)q);
2236 return result;
2237 }
2238
psmat4_look_at(struct mat4 * result,struct vec3 * position,struct vec3 * target,struct vec3 * up_axis)2239 MATHC_INLINE struct mat4 *psmat4_look_at(struct mat4 *result, struct vec3 *position, struct vec3 *target, struct vec3 *up_axis)
2240 {
2241 mat4_look_at((mfloat_t *)result, (mfloat_t *)position, (mfloat_t *)target, (mfloat_t *)up_axis);
2242 return result;
2243 }
2244
psmat4_translation(struct mat4 * result,struct mat4 * v)2245 MATHC_INLINE struct mat4 *psmat4_translation(struct mat4 *result, struct mat4 *v)
2246 {
2247 mat4_translation((mfloat_t *)result, (mfloat_t *)v);
2248 return result;
2249 }
2250
psmat4_scaling(struct mat4 * result,struct mat4 * v)2251 MATHC_INLINE struct mat4 *psmat4_scaling(struct mat4 *result, struct mat4 *v)
2252 {
2253 mat4_scaling((mfloat_t *)result, (mfloat_t *)v);
2254 return result;
2255 }
2256
psmat4_negative(struct mat4 * result,struct mat4 * m)2257 MATHC_INLINE struct mat4 *psmat4_negative(struct mat4 *result, struct mat4 *m)
2258 {
2259 mat4_negative((mfloat_t *)result, (mfloat_t *)m);
2260 return result;
2261 }
2262
psmat4_scale(struct mat4 * result,struct mat4 * m,mfloat_t s)2263 MATHC_INLINE struct mat4 *psmat4_scale(struct mat4 *result, struct mat4 *m, mfloat_t s)
2264 {
2265 mat4_scale((mfloat_t *)result, (mfloat_t *)m, s);
2266 return result;
2267 }
2268
psmat4_multiply(struct mat4 * result,struct mat4 * a,struct mat4 * b)2269 MATHC_INLINE struct mat4 *psmat4_multiply(struct mat4 *result, struct mat4 *a, struct mat4 *b)
2270 {
2271 mat4_multiply((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b);
2272 return result;
2273 }
2274
psmat4_lerp(struct mat4 * result,struct mat4 * a,struct mat4 * b,mfloat_t p)2275 MATHC_INLINE struct mat4 *psmat4_lerp(struct mat4 *result, struct mat4 *a, struct mat4 *b, mfloat_t p)
2276 {
2277 mat4_lerp((mfloat_t *)result, (mfloat_t *)a, (mfloat_t *)b, p);
2278 return result;
2279 }
2280 #endif
2281
2282 #ifndef MATHC_NO_STRUCT_FUNCTIONS
2283 /* Vector 2D */
svec2_is_zero(struct vec2 a)2284 MATHC_INLINE bool svec2_is_zero(struct vec2 a)
2285 {
2286 return vec2_is_zero((mfloat_t *)&a);
2287 }
2288
svec2_is_near_zero(struct vec2 a,mfloat_t epsilon)2289 MATHC_INLINE bool svec2_is_near_zero(struct vec2 a, mfloat_t epsilon)
2290 {
2291 return vec2_is_near_zero((mfloat_t *)&a, epsilon);
2292 }
2293
svec2_is_equal(struct vec2 a,struct vec2 b)2294 MATHC_INLINE bool svec2_is_equal(struct vec2 a, struct vec2 b)
2295 {
2296 return vec2_is_equal((mfloat_t *)&a, (mfloat_t *)&b);
2297 }
2298
svec2_is_nearly_equal(struct vec2 a,struct vec2 b,mfloat_t epsilon)2299 MATHC_INLINE bool svec2_is_nearly_equal(struct vec2 a, struct vec2 b, mfloat_t epsilon)
2300 {
2301 return vec2_is_nearly_equal((mfloat_t *)&a, (mfloat_t *)&b, epsilon);
2302 }
2303
svec2(mfloat_t x,mfloat_t y)2304 MATHC_INLINE struct vec2 svec2(mfloat_t x, mfloat_t y)
2305 {
2306 struct vec2 result;
2307 vec2((mfloat_t *)&result, x, y);
2308 return result;
2309 }
2310
svec2_assign(struct vec2 a)2311 MATHC_INLINE struct vec2 svec2_assign(struct vec2 a)
2312 {
2313 struct vec2 result;
2314 vec2_assign((mfloat_t *)&result, (mfloat_t *)&a);
2315 return result;
2316 }
2317
svec2_assign_vec2i(struct vec2i a)2318 MATHC_INLINE struct vec2 svec2_assign_vec2i(struct vec2i a)
2319 {
2320 struct vec2 result;
2321 vec2_assign_vec2i((mfloat_t *)&result, (mint_t *)&a);
2322 return result;
2323 }
2324
svec2_zero(void)2325 MATHC_INLINE struct vec2 svec2_zero(void)
2326 {
2327 struct vec2 result;
2328 vec2_zero((mfloat_t *)&result);
2329 return result;
2330 }
2331
svec2_one(void)2332 MATHC_INLINE struct vec2 svec2_one(void)
2333 {
2334 struct vec2 result;
2335 vec2_one((mfloat_t *)&result);
2336 return result;
2337 }
2338
svec2_add(struct vec2 a,struct vec2 b)2339 MATHC_INLINE struct vec2 svec2_add(struct vec2 a, struct vec2 b)
2340 {
2341 struct vec2 result;
2342 vec2_add((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2343 return result;
2344 }
2345
svec2_subtract(struct vec2 a,struct vec2 b)2346 MATHC_INLINE struct vec2 svec2_subtract(struct vec2 a, struct vec2 b)
2347 {
2348 struct vec2 result;
2349 vec2_subtract((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2350 return result;
2351 }
2352
svec2_scale(struct vec2 a,mfloat_t scalar)2353 MATHC_INLINE struct vec2 svec2_scale(struct vec2 a, mfloat_t scalar)
2354 {
2355 struct vec2 result;
2356 vec2_scale((mfloat_t *)&result, (mfloat_t *)&a, scalar);
2357 return result;
2358 }
2359
svec2_multiply(struct vec2 a,struct vec2 b)2360 MATHC_INLINE struct vec2 svec2_multiply(struct vec2 a, struct vec2 b)
2361 {
2362 struct vec2 result;
2363 vec2_multiply((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2364 return result;
2365 }
2366
svec2_multiply_mat2(struct vec2 a,struct mat2 m)2367 MATHC_INLINE struct vec2 svec2_multiply_mat2(struct vec2 a, struct mat2 m)
2368 {
2369 struct vec2 result;
2370 vec2_multiply_mat2((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&m);
2371 return result;
2372 }
2373
svec2_divide(struct vec2 a,struct vec2 b)2374 MATHC_INLINE struct vec2 svec2_divide(struct vec2 a, struct vec2 b)
2375 {
2376 struct vec2 result;
2377 vec2_divide((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2378 return result;
2379 }
2380
svec2_snap(struct vec2 a,struct vec2 b)2381 MATHC_INLINE struct vec2 svec2_snap(struct vec2 a, struct vec2 b)
2382 {
2383 struct vec2 result;
2384 vec2_snap((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2385 return result;
2386 }
2387
svec2_negative(struct vec2 a)2388 MATHC_INLINE struct vec2 svec2_negative(struct vec2 a)
2389 {
2390 struct vec2 result;
2391 vec2_negative((mfloat_t *)&result, (mfloat_t *)&a);
2392 return result;
2393 }
2394
svec2_inverse(struct vec2 a)2395 MATHC_INLINE struct vec2 svec2_inverse(struct vec2 a)
2396 {
2397 struct vec2 result;
2398 vec2_inverse((mfloat_t *)&result, (mfloat_t *)&a);
2399 return result;
2400 }
2401
svec2_abs(struct vec2 a)2402 MATHC_INLINE struct vec2 svec2_abs(struct vec2 a)
2403 {
2404 struct vec2 result;
2405 vec2_abs((mfloat_t *)&result, (mfloat_t *)&a);
2406 return result;
2407 }
2408
svec2_floor(struct vec2 a)2409 MATHC_INLINE struct vec2 svec2_floor(struct vec2 a)
2410 {
2411 struct vec2 result;
2412 vec2_floor((mfloat_t *)&result, (mfloat_t *)&a);
2413 return result;
2414 }
2415
svec2_ceil(struct vec2 a)2416 MATHC_INLINE struct vec2 svec2_ceil(struct vec2 a)
2417 {
2418 struct vec2 result;
2419 vec2_ceil((mfloat_t *)&result, (mfloat_t *)&a);
2420 return result;
2421 }
2422
svec2_round(struct vec2 a)2423 MATHC_INLINE struct vec2 svec2_round(struct vec2 a)
2424 {
2425 struct vec2 result;
2426 vec2_round((mfloat_t *)&result, (mfloat_t *)&a);
2427 return result;
2428 }
2429
svec2_max(struct vec2 a,struct vec2 b)2430 MATHC_INLINE struct vec2 svec2_max(struct vec2 a, struct vec2 b)
2431 {
2432 struct vec2 result;
2433 vec2_max((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2434 return result;
2435 }
2436
svec2_min(struct vec2 a,struct vec2 b)2437 MATHC_INLINE struct vec2 svec2_min(struct vec2 a, struct vec2 b)
2438 {
2439 struct vec2 result;
2440 vec2_min((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2441 return result;
2442 }
2443
svec2_clamp(struct vec2 a,struct vec2 lower,struct vec2 higher)2444 MATHC_INLINE struct vec2 svec2_clamp(struct vec2 a, struct vec2 lower, struct vec2 higher)
2445 {
2446 struct vec2 result;
2447 vec2_clamp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&lower, (mfloat_t *)&higher);
2448 return result;
2449 }
2450
svec2_normalize(struct vec2 a)2451 MATHC_INLINE struct vec2 svec2_normalize(struct vec2 a)
2452 {
2453 struct vec2 result;
2454 vec2_normalize((mfloat_t *)&result, (mfloat_t *)&a);
2455 return result;
2456 }
2457
svec2_project(struct vec2 a,struct vec2 b)2458 MATHC_INLINE struct vec2 svec2_project(struct vec2 a, struct vec2 b)
2459 {
2460 struct vec2 result;
2461 vec2_project((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2462 return result;
2463 }
2464
svec2_slide(struct vec2 a,struct vec2 b)2465 MATHC_INLINE struct vec2 svec2_slide(struct vec2 a, struct vec2 b)
2466 {
2467 struct vec2 result;
2468 vec2_slide((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2469 return result;
2470 }
2471
svec2_reflect(struct vec2 a,struct vec2 b)2472 MATHC_INLINE struct vec2 svec2_reflect(struct vec2 a, struct vec2 b)
2473 {
2474 struct vec2 result;
2475 vec2_reflect((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2476 return result;
2477 }
2478
svec2_tangent(struct vec2 a)2479 MATHC_INLINE struct vec2 svec2_tangent(struct vec2 a)
2480 {
2481 struct vec2 result;
2482 vec2_tangent((mfloat_t *)&result, (mfloat_t *)&a);
2483 return result;
2484 }
2485
svec2_rotate(struct vec2 a,mfloat_t angle)2486 MATHC_INLINE struct vec2 svec2_rotate(struct vec2 a, mfloat_t angle)
2487 {
2488 struct vec2 result;
2489 vec2_rotate((mfloat_t *)&result, (mfloat_t *)&a, angle);
2490 return result;
2491 }
2492
svec2_lerp(struct vec2 a,struct vec2 b,mfloat_t p)2493 MATHC_INLINE struct vec2 svec2_lerp(struct vec2 a, struct vec2 b, mfloat_t p)
2494 {
2495 struct vec2 result;
2496 vec2_lerp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, p);
2497 return result;
2498 }
2499
svec2_bezier3(struct vec2 a,struct vec2 b,struct vec2 c,mfloat_t p)2500 MATHC_INLINE struct vec2 svec2_bezier3(struct vec2 a, struct vec2 b, struct vec2 c, mfloat_t p)
2501 {
2502 struct vec2 result;
2503 vec2_bezier3((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, (mfloat_t *)&c, p);
2504 return result;
2505 }
2506
svec2_bezier4(struct vec2 a,struct vec2 b,struct vec2 c,struct vec2 d,mfloat_t p)2507 MATHC_INLINE struct vec2 svec2_bezier4(struct vec2 a, struct vec2 b, struct vec2 c, struct vec2 d, mfloat_t p)
2508 {
2509 struct vec2 result;
2510 vec2_bezier4((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, (mfloat_t *)&c, (mfloat_t *)&d, p);
2511 return result;
2512 }
2513
svec2_dot(struct vec2 a,struct vec2 b)2514 MATHC_INLINE mfloat_t svec2_dot(struct vec2 a, struct vec2 b)
2515 {
2516 return vec2_dot((mfloat_t *)&a, (mfloat_t *)&b);
2517 }
2518
svec2_angle(struct vec2 a)2519 MATHC_INLINE mfloat_t svec2_angle(struct vec2 a)
2520 {
2521 return vec2_angle((mfloat_t *)&a);
2522 }
2523
svec2_length_squared(struct vec2 a)2524 MATHC_INLINE mfloat_t svec2_length_squared(struct vec2 a)
2525 {
2526 return vec2_length_squared((mfloat_t *)&a);
2527 }
2528
svec2_length(struct vec2 a)2529 MATHC_INLINE mfloat_t svec2_length(struct vec2 a)
2530 {
2531 return vec2_length((mfloat_t *)&a);
2532 }
2533
svec2_distance(struct vec2 a,struct vec2 b)2534 MATHC_INLINE mfloat_t svec2_distance(struct vec2 a, struct vec2 b)
2535 {
2536 return vec2_distance((mfloat_t *)&a, (mfloat_t *)&b);
2537 }
2538
svec2_distance_squared(struct vec2 a,struct vec2 b)2539 MATHC_INLINE mfloat_t svec2_distance_squared(struct vec2 a, struct vec2 b)
2540 {
2541 return vec2_distance_squared((mfloat_t *)&a, (mfloat_t *)&b);
2542 }
2543
2544 /* Vector 2D Integer */
svec2i_is_zero(struct vec2i a)2545 MATHC_INLINE bool svec2i_is_zero(struct vec2i a)
2546 {
2547 return vec2i_is_zero((mint_t *)&a);
2548 }
2549
svec2i_is_equal(struct vec2i a,struct vec2i b)2550 MATHC_INLINE bool svec2i_is_equal(struct vec2i a, struct vec2i b)
2551 {
2552 return vec2i_is_equal((mint_t *)&a, (mint_t *)&b);
2553 }
2554
svec2i(mint_t x,mint_t y)2555 MATHC_INLINE struct vec2i svec2i(mint_t x, mint_t y)
2556 {
2557 struct vec2i result;
2558 vec2i((mint_t *)&result, x, y);
2559 return result;
2560 }
2561
svec2i_assign(struct vec2i a)2562 MATHC_INLINE struct vec2i svec2i_assign(struct vec2i a)
2563 {
2564 struct vec2i result;
2565 vec2i_assign((mint_t *)&result, (mint_t *)&a);
2566 return result;
2567 }
2568
svec2i_assign_vec2(struct vec2 a)2569 MATHC_INLINE struct vec2i svec2i_assign_vec2(struct vec2 a)
2570 {
2571 struct vec2i result;
2572 vec2i_assign_vec2((mint_t *)&result, (mfloat_t *)&a);
2573 return result;
2574 }
2575
svec2i_zero(void)2576 MATHC_INLINE struct vec2i svec2i_zero(void)
2577 {
2578 struct vec2i result;
2579 vec2i_zero((mint_t *)&result);
2580 return result;
2581 }
2582
svec2i_one(void)2583 MATHC_INLINE struct vec2i svec2i_one(void)
2584 {
2585 struct vec2i result;
2586 vec2i_one((mint_t *)&result);
2587 return result;
2588 }
2589
svec2i_add(struct vec2i a,struct vec2i b)2590 MATHC_INLINE struct vec2i svec2i_add(struct vec2i a, struct vec2i b)
2591 {
2592 struct vec2i result;
2593 vec2i_add((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
2594 return result;
2595 }
2596
svec2i_subtract(struct vec2i a,struct vec2i b)2597 MATHC_INLINE struct vec2i svec2i_subtract(struct vec2i a, struct vec2i b)
2598 {
2599 struct vec2i result;
2600 vec2i_subtract((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
2601 return result;
2602 }
2603
svec2i_scale(struct vec2i a,mfloat_t scalar)2604 MATHC_INLINE struct vec2i svec2i_scale(struct vec2i a, mfloat_t scalar)
2605 {
2606 struct vec2i result;
2607 vec2i_scale((mint_t *)&result, (mint_t *)&a, scalar);
2608 return result;
2609 }
2610
svec2i_multiply(struct vec2i a,struct vec2i b)2611 MATHC_INLINE struct vec2i svec2i_multiply(struct vec2i a, struct vec2i b)
2612 {
2613 struct vec2i result;
2614 vec2i_multiply((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
2615 return result;
2616 }
2617
svec2i_multiply_mat2(struct vec2i a,struct mat2 m)2618 MATHC_INLINE struct vec2i svec2i_multiply_mat2(struct vec2i a, struct mat2 m)
2619 {
2620 struct vec2i result;
2621 vec2i_multiply_mat2((mint_t *)&result, (mint_t *)&a, (mfloat_t *)&m);
2622 return result;
2623 }
2624
svec2i_divide(struct vec2i a,struct vec2i b)2625 MATHC_INLINE struct vec2i svec2i_divide(struct vec2i a, struct vec2i b)
2626 {
2627 struct vec2i result;
2628 vec2i_divide((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
2629 return result;
2630 }
2631
svec2i_snap(struct vec2i a,struct vec2i b)2632 MATHC_INLINE struct vec2i svec2i_snap(struct vec2i a, struct vec2i b)
2633 {
2634 struct vec2i result;
2635 vec2i_snap((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
2636 return result;
2637 }
2638
svec2i_negative(struct vec2i a)2639 MATHC_INLINE struct vec2i svec2i_negative(struct vec2i a)
2640 {
2641 struct vec2i result;
2642 vec2i_negative((mint_t *)&result, (mint_t *)&a);
2643 return result;
2644 }
2645
svec2i_inverse(struct vec2i a)2646 MATHC_INLINE struct vec2i svec2i_inverse(struct vec2i a)
2647 {
2648 struct vec2i result;
2649 vec2i_inverse((mint_t *)&result, (mint_t *)&a);
2650 return result;
2651 }
2652
svec2i_abs(struct vec2i a)2653 MATHC_INLINE struct vec2i svec2i_abs(struct vec2i a)
2654 {
2655 struct vec2i result;
2656 vec2i_abs((mint_t *)&result, (mint_t *)&a);
2657 return result;
2658 }
2659
svec2i_floor(struct vec2 a)2660 MATHC_INLINE struct vec2i svec2i_floor(struct vec2 a)
2661 {
2662 struct vec2i result;
2663 vec2i_floor((mint_t *)&result, (mfloat_t *)&a);
2664 return result;
2665 }
2666
svec2i_ceil(struct vec2 a)2667 MATHC_INLINE struct vec2i svec2i_ceil(struct vec2 a)
2668 {
2669 struct vec2i result;
2670 vec2i_ceil((mint_t *)&result, (mfloat_t *)&a);
2671 return result;
2672 }
2673
svec2i_round(struct vec2 a)2674 MATHC_INLINE struct vec2i svec2i_round(struct vec2 a)
2675 {
2676 struct vec2i result;
2677 vec2i_round((mint_t *)&result, (mfloat_t *)&a);
2678 return result;
2679 }
2680
svec2i_max(struct vec2i a,struct vec2i b)2681 MATHC_INLINE struct vec2i svec2i_max(struct vec2i a, struct vec2i b)
2682 {
2683 struct vec2i result;
2684 vec2i_max((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
2685 return result;
2686 }
2687
svec2i_min(struct vec2i a,struct vec2i b)2688 MATHC_INLINE struct vec2i svec2i_min(struct vec2i a, struct vec2i b)
2689 {
2690 struct vec2i result;
2691 vec2i_min((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
2692 return result;
2693 }
2694
svec2i_clamp(struct vec2i a,struct vec2i lower,struct vec2i higher)2695 MATHC_INLINE struct vec2i svec2i_clamp(struct vec2i a, struct vec2i lower, struct vec2i higher)
2696 {
2697 struct vec2i result;
2698 vec2i_clamp((mint_t *)&result, (mint_t *)&a, (mint_t *)&lower, (mint_t *)&higher);
2699 return result;
2700 }
2701
svec2i_normalize(struct vec2i a)2702 MATHC_INLINE struct vec2i svec2i_normalize(struct vec2i a)
2703 {
2704 struct vec2i result;
2705 vec2i_normalize((mint_t *)&result, (mint_t *)&a);
2706 return result;
2707 }
2708
svec2i_project(struct vec2i a,struct vec2i b)2709 MATHC_INLINE struct vec2i svec2i_project(struct vec2i a, struct vec2i b)
2710 {
2711 struct vec2i result;
2712 vec2i_project((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
2713 return result;
2714 }
2715
svec2i_slide(struct vec2i a,struct vec2i b)2716 MATHC_INLINE struct vec2i svec2i_slide(struct vec2i a, struct vec2i b)
2717 {
2718 struct vec2i result;
2719 vec2i_slide((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
2720 return result;
2721 }
2722
svec2i_reflect(struct vec2i a,struct vec2i b)2723 MATHC_INLINE struct vec2i svec2i_reflect(struct vec2i a, struct vec2i b)
2724 {
2725 struct vec2i result;
2726 vec2i_reflect((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
2727 return result;
2728 }
2729
svec2i_tangent(struct vec2i a)2730 MATHC_INLINE struct vec2i svec2i_tangent(struct vec2i a)
2731 {
2732 struct vec2i result;
2733 vec2i_tangent((mint_t *)&result, (mint_t *)&a);
2734 return result;
2735 }
2736
svec2i_rotate(struct vec2i a,mfloat_t angle)2737 MATHC_INLINE struct vec2i svec2i_rotate(struct vec2i a, mfloat_t angle)
2738 {
2739 struct vec2i result;
2740 vec2i_rotate((mint_t *)&result, (mint_t *)&a, angle);
2741 return result;
2742 }
2743
svec2i_lerp(struct vec2i a,struct vec2i b,mfloat_t p)2744 MATHC_INLINE struct vec2i svec2i_lerp(struct vec2i a, struct vec2i b, mfloat_t p)
2745 {
2746 struct vec2i result;
2747 vec2i_lerp((mint_t *)&result, (mint_t *)&a, (mint_t *)&b, p);
2748 return result;
2749 }
2750
svec2i_bezier3(struct vec2i a,struct vec2i b,struct vec2i c,mfloat_t p)2751 MATHC_INLINE struct vec2i svec2i_bezier3(struct vec2i a, struct vec2i b, struct vec2i c, mfloat_t p)
2752 {
2753 struct vec2i result;
2754 vec2i_bezier3((mint_t *)&result, (mint_t *)&a, (mint_t *)&b, (mint_t *)&c, p);
2755 return result;
2756 }
2757
svec2i_bezier4(struct vec2i a,struct vec2i b,struct vec2i c,struct vec2i d,mfloat_t p)2758 MATHC_INLINE struct vec2i svec2i_bezier4(struct vec2i a, struct vec2i b, struct vec2i c, struct vec2i d, mfloat_t p)
2759 {
2760 struct vec2i result;
2761 vec2i_bezier4((mint_t *)&result, (mint_t *)&a, (mint_t *)&b, (mint_t *)&c, (mint_t *)&d, p);
2762 return result;
2763 }
2764
svec2i_dot(struct vec2i a,struct vec2i b)2765 MATHC_INLINE mint_t svec2i_dot(struct vec2i a, struct vec2i b)
2766 {
2767 return vec2i_dot((mint_t *)&a, (mint_t *)&b);
2768 }
2769
svec2i_angle(struct vec2i a)2770 MATHC_INLINE mfloat_t svec2i_angle(struct vec2i a)
2771 {
2772 return vec2i_angle((mint_t *)&a);
2773 }
2774
svec2i_length_squared(struct vec2i a)2775 MATHC_INLINE mint_t svec2i_length_squared(struct vec2i a)
2776 {
2777 return vec2i_length_squared((mint_t *)&a);
2778 }
2779
svec2i_length(struct vec2i a)2780 MATHC_INLINE mfloat_t svec2i_length(struct vec2i a)
2781 {
2782 return vec2i_length((mint_t *)&a);
2783 }
2784
svec2i_distance(struct vec2i a,struct vec2i b)2785 MATHC_INLINE mfloat_t svec2i_distance(struct vec2i a, struct vec2i b)
2786 {
2787 return vec2i_distance((mint_t *)&a, (mint_t *)&b);
2788 }
2789
svec2i_distance_squared(struct vec2i a,struct vec2i b)2790 MATHC_INLINE mint_t svec2i_distance_squared(struct vec2i a, struct vec2i b)
2791 {
2792 return vec2i_distance_squared((mint_t *)&a, (mint_t *)&b);
2793 }
2794
2795 /* Vector 3 */
svec3_is_zero(struct vec3 a)2796 MATHC_INLINE bool svec3_is_zero(struct vec3 a)
2797 {
2798 return vec3_is_zero((mfloat_t *)&a);
2799 }
2800
svec3_is_near_zero(struct vec3 a,mfloat_t epsilon)2801 MATHC_INLINE bool svec3_is_near_zero(struct vec3 a, mfloat_t epsilon)
2802 {
2803 return vec3_is_near_zero((mfloat_t *)&a, epsilon);
2804 }
2805
svec3_is_equal(struct vec3 a,struct vec3 b)2806 MATHC_INLINE bool svec3_is_equal(struct vec3 a, struct vec3 b)
2807 {
2808 return vec3_is_equal((mfloat_t *)&a, (mfloat_t *)&b);
2809 }
2810
svec3_is_nearly_equal(struct vec3 a,struct vec3 b,mfloat_t epsilon)2811 MATHC_INLINE bool svec3_is_nearly_equal(struct vec3 a, struct vec3 b, mfloat_t epsilon)
2812 {
2813 return vec3_is_nearly_equal((mfloat_t *)&a, (mfloat_t *)&b, epsilon);
2814 }
2815
svec3(mfloat_t x,mfloat_t y,mfloat_t z)2816 MATHC_INLINE struct vec3 svec3(mfloat_t x, mfloat_t y, mfloat_t z)
2817 {
2818 struct vec3 result;
2819 vec3((mfloat_t *)&result, x, y, z);
2820 return result;
2821 }
2822
svec3_assign(struct vec3 a)2823 MATHC_INLINE struct vec3 svec3_assign(struct vec3 a)
2824 {
2825 struct vec3 result;
2826 vec3_assign((mfloat_t *)&result, (mfloat_t *)&a);
2827 return result;
2828 }
2829
svec3_assign_vec3i(struct vec3i a)2830 MATHC_INLINE struct vec3 svec3_assign_vec3i(struct vec3i a)
2831 {
2832 struct vec3 result;
2833 vec3_assign_vec3i((mfloat_t *)&result, (mint_t *)&a);
2834 return result;
2835 }
2836
svec3_zero(void)2837 MATHC_INLINE struct vec3 svec3_zero(void)
2838 {
2839 struct vec3 result;
2840 vec3_zero((mfloat_t *)&result);
2841 return result;
2842 }
2843
svec3_one(void)2844 MATHC_INLINE struct vec3 svec3_one(void)
2845 {
2846 struct vec3 result;
2847 vec3_one((mfloat_t *)&result);
2848 return result;
2849 }
2850
svec3_add(struct vec3 a,struct vec3 b)2851 MATHC_INLINE struct vec3 svec3_add(struct vec3 a, struct vec3 b)
2852 {
2853 struct vec3 result;
2854 vec3_add((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2855 return result;
2856 }
2857
svec3_subtract(struct vec3 a,struct vec3 b)2858 MATHC_INLINE struct vec3 svec3_subtract(struct vec3 a, struct vec3 b)
2859 {
2860 struct vec3 result;
2861 vec3_subtract((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2862 return result;
2863 }
2864
svec3_scale(struct vec3 a,mfloat_t scalar)2865 MATHC_INLINE struct vec3 svec3_scale(struct vec3 a, mfloat_t scalar)
2866 {
2867 struct vec3 result;
2868 vec3_scale((mfloat_t *)&result, (mfloat_t *)&a, scalar);
2869 return result;
2870 }
2871
svec3_multiply(struct vec3 a,struct vec3 b)2872 MATHC_INLINE struct vec3 svec3_multiply(struct vec3 a, struct vec3 b)
2873 {
2874 struct vec3 result;
2875 vec3_multiply((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2876 return result;
2877 }
2878
svec3_multiply_mat3(struct vec3 a,struct mat3 m)2879 MATHC_INLINE struct vec3 svec3_multiply_mat3(struct vec3 a, struct mat3 m)
2880 {
2881 struct vec3 result;
2882 vec3_multiply_mat3((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&m);
2883 return result;
2884 }
2885
svec3_divide(struct vec3 a,struct vec3 b)2886 MATHC_INLINE struct vec3 svec3_divide(struct vec3 a, struct vec3 b)
2887 {
2888 struct vec3 result;
2889 vec3_divide((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2890 return result;
2891 }
2892
svec3_snap(struct vec3 a,struct vec3 b)2893 MATHC_INLINE struct vec3 svec3_snap(struct vec3 a, struct vec3 b)
2894 {
2895 struct vec3 result;
2896 vec3_snap((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2897 return result;
2898 }
2899
svec3_negative(struct vec3 a)2900 MATHC_INLINE struct vec3 svec3_negative(struct vec3 a)
2901 {
2902 struct vec3 result;
2903 vec3_negative((mfloat_t *)&result, (mfloat_t *)&a);
2904 return result;
2905 }
2906
svec3_inverse(struct vec3 a)2907 MATHC_INLINE struct vec3 svec3_inverse(struct vec3 a)
2908 {
2909 struct vec3 result;
2910 vec3_inverse((mfloat_t *)&result, (mfloat_t *)&a);
2911 return result;
2912 }
2913
svec3_abs(struct vec3 a)2914 MATHC_INLINE struct vec3 svec3_abs(struct vec3 a)
2915 {
2916 struct vec3 result;
2917 vec3_abs((mfloat_t *)&result, (mfloat_t *)&a);
2918 return result;
2919 }
2920
svec3_floor(struct vec3 a)2921 MATHC_INLINE struct vec3 svec3_floor(struct vec3 a)
2922 {
2923 struct vec3 result;
2924 vec3_floor((mfloat_t *)&result, (mfloat_t *)&a);
2925 return result;
2926 }
2927
svec3_ceil(struct vec3 a)2928 MATHC_INLINE struct vec3 svec3_ceil(struct vec3 a)
2929 {
2930 struct vec3 result;
2931 vec3_ceil((mfloat_t *)&result, (mfloat_t *)&a);
2932 return result;
2933 }
2934
svec3_round(struct vec3 a)2935 MATHC_INLINE struct vec3 svec3_round(struct vec3 a)
2936 {
2937 struct vec3 result;
2938 vec3_round((mfloat_t *)&result, (mfloat_t *)&a);
2939 return result;
2940 }
2941
svec3_max(struct vec3 a,struct vec3 b)2942 MATHC_INLINE struct vec3 svec3_max(struct vec3 a, struct vec3 b)
2943 {
2944 struct vec3 result;
2945 vec3_max((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2946 return result;
2947 }
2948
svec3_min(struct vec3 a,struct vec3 b)2949 MATHC_INLINE struct vec3 svec3_min(struct vec3 a, struct vec3 b)
2950 {
2951 struct vec3 result;
2952 vec3_min((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2953 return result;
2954 }
2955
svec3_clamp(struct vec3 a,struct vec3 lower,struct vec3 higher)2956 MATHC_INLINE struct vec3 svec3_clamp(struct vec3 a, struct vec3 lower, struct vec3 higher)
2957 {
2958 struct vec3 result;
2959 vec3_clamp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&lower, (mfloat_t *)&higher);
2960 return result;
2961 }
2962
svec3_cross(struct vec3 a,struct vec3 b)2963 MATHC_INLINE struct vec3 svec3_cross(struct vec3 a, struct vec3 b)
2964 {
2965 struct vec3 result;
2966 vec3_cross((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2967 return result;
2968 }
2969
svec3_normalize(struct vec3 a)2970 MATHC_INLINE struct vec3 svec3_normalize(struct vec3 a)
2971 {
2972 struct vec3 result;
2973 vec3_normalize((mfloat_t *)&result, (mfloat_t *)&a);
2974 return result;
2975 }
2976
svec3_project(struct vec3 a,struct vec3 b)2977 MATHC_INLINE struct vec3 svec3_project(struct vec3 a, struct vec3 b)
2978 {
2979 struct vec3 result;
2980 vec3_project((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2981 return result;
2982 }
2983
svec3_slide(struct vec3 a,struct vec3 b)2984 MATHC_INLINE struct vec3 svec3_slide(struct vec3 a, struct vec3 b)
2985 {
2986 struct vec3 result;
2987 vec3_slide((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2988 return result;
2989 }
2990
svec3_reflect(struct vec3 a,struct vec3 b)2991 MATHC_INLINE struct vec3 svec3_reflect(struct vec3 a, struct vec3 b)
2992 {
2993 struct vec3 result;
2994 vec3_reflect((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
2995 return result;
2996 }
2997
svec3_lerp(struct vec3 a,struct vec3 b,mfloat_t p)2998 MATHC_INLINE struct vec3 svec3_lerp(struct vec3 a, struct vec3 b, mfloat_t p)
2999 {
3000 struct vec3 result;
3001 vec3_lerp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, p);
3002 return result;
3003 }
3004
svec3_bezier3(struct vec3 a,struct vec3 b,struct vec3 c,mfloat_t p)3005 MATHC_INLINE struct vec3 svec3_bezier3(struct vec3 a, struct vec3 b, struct vec3 c, mfloat_t p)
3006 {
3007 struct vec3 result;
3008 vec3_bezier3((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, (mfloat_t *)&c, p);
3009 return result;
3010 }
3011
svec3_bezier4(struct vec3 a,struct vec3 b,struct vec3 c,struct vec3 d,mfloat_t p)3012 MATHC_INLINE struct vec3 svec3_bezier4(struct vec3 a, struct vec3 b, struct vec3 c, struct vec3 d, mfloat_t p)
3013 {
3014 struct vec3 result;
3015 vec3_bezier4((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, (mfloat_t *)&c, (mfloat_t *)&d, p);
3016 return result;
3017 }
3018
svec3_dot(struct vec3 a,struct vec3 b)3019 MATHC_INLINE mfloat_t svec3_dot(struct vec3 a, struct vec3 b)
3020 {
3021 return vec3_dot((mfloat_t *)&a, (mfloat_t *)&b);
3022 }
3023
svec3_length(struct vec3 a)3024 MATHC_INLINE mfloat_t svec3_length(struct vec3 a)
3025 {
3026 return vec3_length((mfloat_t *)&a);
3027 }
3028
svec3_length_squared(struct vec3 a)3029 MATHC_INLINE mfloat_t svec3_length_squared(struct vec3 a)
3030 {
3031 return vec3_length_squared((mfloat_t *)&a);
3032 }
3033
svec3_distance(struct vec3 a,struct vec3 b)3034 MATHC_INLINE mfloat_t svec3_distance(struct vec3 a, struct vec3 b)
3035 {
3036 return vec3_distance((mfloat_t *)&a, (mfloat_t *)&b);
3037 }
3038
svec3_distance_squared(struct vec3 a,struct vec3 b)3039 MATHC_INLINE mfloat_t svec3_distance_squared(struct vec3 a, struct vec3 b)
3040 {
3041 return vec3_distance_squared((mfloat_t *)&a, (mfloat_t *)&b);
3042 }
3043
3044 /* Vector 3 Integer */
svec3i_is_zero(struct vec3i a)3045 MATHC_INLINE bool svec3i_is_zero(struct vec3i a)
3046 {
3047 return vec3i_is_zero((mint_t *)&a);
3048 }
3049
svec3i_is_equal(struct vec3i a,struct vec3i b)3050 MATHC_INLINE bool svec3i_is_equal(struct vec3i a, struct vec3i b)
3051 {
3052 return vec3i_is_equal((mint_t *)&a, (mint_t *)&b);
3053 }
3054
svec3i(mint_t x,mint_t y,mint_t z)3055 MATHC_INLINE struct vec3i svec3i(mint_t x, mint_t y, mint_t z)
3056 {
3057 struct vec3i result;
3058 vec3i((mint_t *)&result, x, y, z);
3059 return result;
3060 }
3061
svec3i_assign(struct vec3i a)3062 MATHC_INLINE struct vec3i svec3i_assign(struct vec3i a)
3063 {
3064 struct vec3i result;
3065 vec3i_assign((mint_t *)&result, (mint_t *)&a);
3066 return result;
3067 }
3068
svec3i_assign_vec3(struct vec3 a)3069 MATHC_INLINE struct vec3i svec3i_assign_vec3(struct vec3 a)
3070 {
3071 struct vec3i result;
3072 vec3i_assign_vec3((mint_t *)&result, (mfloat_t *)&a);
3073 return result;
3074 }
3075
svec3i_zero(void)3076 MATHC_INLINE struct vec3i svec3i_zero(void)
3077 {
3078 struct vec3i result;
3079 vec3i_zero((mint_t *)&result);
3080 return result;
3081 }
3082
svec3i_one(void)3083 MATHC_INLINE struct vec3i svec3i_one(void)
3084 {
3085 struct vec3i result;
3086 vec3i_one((mint_t *)&result);
3087 return result;
3088 }
3089
svec3i_add(struct vec3i a,struct vec3i b)3090 MATHC_INLINE struct vec3i svec3i_add(struct vec3i a, struct vec3i b)
3091 {
3092 struct vec3i result;
3093 vec3i_add((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3094 return result;
3095 }
3096
svec3i_subtract(struct vec3i a,struct vec3i b)3097 MATHC_INLINE struct vec3i svec3i_subtract(struct vec3i a, struct vec3i b)
3098 {
3099 struct vec3i result;
3100 vec3i_subtract((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3101 return result;
3102 }
3103
svec3i_scale(struct vec3i a,mfloat_t scalar)3104 MATHC_INLINE struct vec3i svec3i_scale(struct vec3i a, mfloat_t scalar)
3105 {
3106 struct vec3i result;
3107 vec3i_scale((mint_t *)&result, (mint_t *)&a, scalar);
3108 return result;
3109 }
3110
svec3i_multiply(struct vec3i a,struct vec3i b)3111 MATHC_INLINE struct vec3i svec3i_multiply(struct vec3i a, struct vec3i b)
3112 {
3113 struct vec3i result;
3114 vec3i_multiply((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3115 return result;
3116 }
3117
svec3i_multiply_mat3(struct vec3i a,struct mat3 m)3118 MATHC_INLINE struct vec3i svec3i_multiply_mat3(struct vec3i a, struct mat3 m)
3119 {
3120 struct vec3i result;
3121 vec3i_multiply_mat3((mint_t *)&result, (mint_t *)&a, (mfloat_t *)&m);
3122 return result;
3123 }
3124
svec3i_divide(struct vec3i a,struct vec3i b)3125 MATHC_INLINE struct vec3i svec3i_divide(struct vec3i a, struct vec3i b)
3126 {
3127 struct vec3i result;
3128 vec3i_divide((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3129 return result;
3130 }
3131
svec3i_snap(struct vec3i a,struct vec3i b)3132 MATHC_INLINE struct vec3i svec3i_snap(struct vec3i a, struct vec3i b)
3133 {
3134 struct vec3i result;
3135 vec3i_snap((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3136 return result;
3137 }
3138
svec3i_negative(struct vec3i a)3139 MATHC_INLINE struct vec3i svec3i_negative(struct vec3i a)
3140 {
3141 struct vec3i result;
3142 vec3i_negative((mint_t *)&result, (mint_t *)&a);
3143 return result;
3144 }
3145
svec3i_inverse(struct vec3i a)3146 MATHC_INLINE struct vec3i svec3i_inverse(struct vec3i a)
3147 {
3148 struct vec3i result;
3149 vec3i_inverse((mint_t *)&result, (mint_t *)&a);
3150 return result;
3151 }
3152
svec3i_abs(struct vec3i a)3153 MATHC_INLINE struct vec3i svec3i_abs(struct vec3i a)
3154 {
3155 struct vec3i result;
3156 vec3i_abs((mint_t *)&result, (mint_t *)&a);
3157 return result;
3158 }
3159
svec3i_floor(struct vec3 a)3160 MATHC_INLINE struct vec3i svec3i_floor(struct vec3 a)
3161 {
3162 struct vec3i result;
3163 vec3i_floor((mint_t *)&result, (mfloat_t *)&a);
3164 return result;
3165 }
3166
svec3i_ceil(struct vec3 a)3167 MATHC_INLINE struct vec3i svec3i_ceil(struct vec3 a)
3168 {
3169 struct vec3i result;
3170 vec3i_ceil((mint_t *)&result, (mfloat_t *)&a);
3171 return result;
3172 }
3173
svec3i_round(struct vec3 a)3174 MATHC_INLINE struct vec3i svec3i_round(struct vec3 a)
3175 {
3176 struct vec3i result;
3177 vec3i_round((mint_t *)&result, (mfloat_t *)&a);
3178 return result;
3179 }
3180
svec3i_max(struct vec3i a,struct vec3i b)3181 MATHC_INLINE struct vec3i svec3i_max(struct vec3i a, struct vec3i b)
3182 {
3183 struct vec3i result;
3184 vec3i_max((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3185 return result;
3186 }
3187
svec3i_min(struct vec3i a,struct vec3i b)3188 MATHC_INLINE struct vec3i svec3i_min(struct vec3i a, struct vec3i b)
3189 {
3190 struct vec3i result;
3191 vec3i_min((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3192 return result;
3193 }
3194
svec3i_clamp(struct vec3i a,struct vec3i lower,struct vec3i higher)3195 MATHC_INLINE struct vec3i svec3i_clamp(struct vec3i a, struct vec3i lower, struct vec3i higher)
3196 {
3197 struct vec3i result;
3198 vec3i_clamp((mint_t *)&result, (mint_t *)&a, (mint_t *)&lower, (mint_t *)&higher);
3199 return result;
3200 }
3201
svec3i_cross(struct vec3i a,struct vec3i b)3202 MATHC_INLINE struct vec3i svec3i_cross(struct vec3i a, struct vec3i b)
3203 {
3204 struct vec3i result;
3205 vec3i_cross((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3206 return result;
3207 }
3208
svec3i_normalize(struct vec3i a)3209 MATHC_INLINE struct vec3i svec3i_normalize(struct vec3i a)
3210 {
3211 struct vec3i result;
3212 vec3i_normalize((mint_t *)&result, (mint_t *)&a);
3213 return result;
3214 }
3215
svec3i_project(struct vec3i a,struct vec3i b)3216 MATHC_INLINE struct vec3i svec3i_project(struct vec3i a, struct vec3i b)
3217 {
3218 struct vec3i result;
3219 vec3i_project((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3220 return result;
3221 }
3222
svec3i_slide(struct vec3i a,struct vec3i b)3223 MATHC_INLINE struct vec3i svec3i_slide(struct vec3i a, struct vec3i b)
3224 {
3225 struct vec3i result;
3226 vec3i_slide((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3227 return result;
3228 }
3229
svec3i_reflect(struct vec3i a,struct vec3i b)3230 MATHC_INLINE struct vec3i svec3i_reflect(struct vec3i a, struct vec3i b)
3231 {
3232 struct vec3i result;
3233 vec3i_reflect((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3234 return result;
3235 }
3236
svec3i_lerp(struct vec3i a,struct vec3i b,mfloat_t p)3237 MATHC_INLINE struct vec3i svec3i_lerp(struct vec3i a, struct vec3i b, mfloat_t p)
3238 {
3239 struct vec3i result;
3240 vec3i_lerp((mint_t *)&result, (mint_t *)&a, (mint_t *)&b, p);
3241 return result;
3242 }
3243
svec3i_bezier3(struct vec3i a,struct vec3i b,struct vec3i c,mfloat_t p)3244 MATHC_INLINE struct vec3i svec3i_bezier3(struct vec3i a, struct vec3i b, struct vec3i c, mfloat_t p)
3245 {
3246 struct vec3i result;
3247 vec3i_bezier3((mint_t *)&result, (mint_t *)&a, (mint_t *)&b, (mint_t *)&c, p);
3248 return result;
3249 }
3250
svec3i_bezier4(struct vec3i a,struct vec3i b,struct vec3i c,struct vec3i d,mfloat_t p)3251 MATHC_INLINE struct vec3i svec3i_bezier4(struct vec3i a, struct vec3i b, struct vec3i c, struct vec3i d, mfloat_t p)
3252 {
3253 struct vec3i result;
3254 vec3i_bezier4((mint_t *)&result, (mint_t *)&a, (mint_t *)&b, (mint_t *)&c, (mint_t *)&d, p);
3255 return result;
3256 }
3257
svec3i_dot(struct vec3i a,struct vec3i b)3258 MATHC_INLINE mint_t svec3i_dot(struct vec3i a, struct vec3i b)
3259 {
3260 return vec3i_dot((mint_t *)&a, (mint_t *)&b);
3261 }
3262
svec3i_length(struct vec3i a)3263 MATHC_INLINE mfloat_t svec3i_length(struct vec3i a)
3264 {
3265 return vec3i_length((mint_t *)&a);
3266 }
3267
svec3i_length_squared(struct vec3i a)3268 MATHC_INLINE mint_t svec3i_length_squared(struct vec3i a)
3269 {
3270 return vec3i_length_squared((mint_t *)&a);
3271 }
3272
svec3i_distance(struct vec3i a,struct vec3i b)3273 MATHC_INLINE mfloat_t svec3i_distance(struct vec3i a, struct vec3i b)
3274 {
3275 return vec3i_distance((mint_t *)&a, (mint_t *)&b);
3276 }
3277
svec3i_distance_squared(struct vec3i a,struct vec3i b)3278 MATHC_INLINE mint_t svec3i_distance_squared(struct vec3i a, struct vec3i b)
3279 {
3280 return vec3i_distance_squared((mint_t *)&a, (mint_t *)&b);
3281 }
3282
3283 /* Vector 4D */
svec4_is_zero(struct vec4 a)3284 MATHC_INLINE bool svec4_is_zero(struct vec4 a)
3285 {
3286 return vec4_is_zero((mfloat_t *)&a);
3287 }
3288
svec4_is_near_zero(struct vec4 a,mfloat_t epsilon)3289 MATHC_INLINE bool svec4_is_near_zero(struct vec4 a, mfloat_t epsilon)
3290 {
3291 return vec4_is_near_zero((mfloat_t *)&a, epsilon);
3292 }
3293
svec4_is_equal(struct vec4 a,struct vec4 b)3294 MATHC_INLINE bool svec4_is_equal(struct vec4 a, struct vec4 b)
3295 {
3296 return vec4_is_equal((mfloat_t *)&a, (mfloat_t *)&b);
3297 }
3298
svec4_is_nearly_equal(struct vec4 a,struct vec4 b,mfloat_t epsilon)3299 MATHC_INLINE bool svec4_is_nearly_equal(struct vec4 a, struct vec4 b, mfloat_t epsilon)
3300 {
3301 return vec4_is_nearly_equal((mfloat_t *)&a, (mfloat_t *)&b, epsilon);
3302 }
3303
svec4(mfloat_t x,mfloat_t y,mfloat_t z,mfloat_t w)3304 MATHC_INLINE struct vec4 svec4(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
3305 {
3306 struct vec4 result;
3307 vec4((mfloat_t *)&result, x, y, z, w);
3308 return result;
3309 }
3310
svec4_assign(struct vec4 a)3311 MATHC_INLINE struct vec4 svec4_assign(struct vec4 a)
3312 {
3313 struct vec4 result;
3314 vec4_assign((mfloat_t *)&result, (mfloat_t *)&a);
3315 return result;
3316 }
3317
svec4_assign_vec4i(struct vec4i a)3318 MATHC_INLINE struct vec4 svec4_assign_vec4i(struct vec4i a)
3319 {
3320 struct vec4 result;
3321 vec4_assign_vec4i((mfloat_t *)&result, (mint_t *)&a);
3322 return result;
3323 }
3324
svec4_zero(void)3325 MATHC_INLINE struct vec4 svec4_zero(void)
3326 {
3327 struct vec4 result;
3328 vec4_zero((mfloat_t *)&result);
3329 return result;
3330 }
3331
svec4_one(void)3332 MATHC_INLINE struct vec4 svec4_one(void)
3333 {
3334 struct vec4 result;
3335 vec4_one((mfloat_t *)&result);
3336 return result;
3337 }
3338
svec4_add(struct vec4 a,struct vec4 b)3339 MATHC_INLINE struct vec4 svec4_add(struct vec4 a, struct vec4 b)
3340 {
3341 struct vec4 result;
3342 vec4_add((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3343 return result;
3344 }
3345
svec4_subtract(struct vec4 a,struct vec4 b)3346 MATHC_INLINE struct vec4 svec4_subtract(struct vec4 a, struct vec4 b)
3347 {
3348 struct vec4 result;
3349 vec4_subtract((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3350 return result;
3351 }
3352
svec4_scale(struct vec4 a,mfloat_t scalar)3353 MATHC_INLINE struct vec4 svec4_scale(struct vec4 a, mfloat_t scalar)
3354 {
3355 struct vec4 result;
3356 vec4_scale((mfloat_t *)&result, (mfloat_t *)&a, scalar);
3357 return result;
3358 }
3359
svec4_multiply(struct vec4 a,struct vec4 b)3360 MATHC_INLINE struct vec4 svec4_multiply(struct vec4 a, struct vec4 b)
3361 {
3362 struct vec4 result;
3363 vec4_multiply((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3364 return result;
3365 }
3366
svec4_multiply_mat4(struct vec4 a,struct mat4 m)3367 MATHC_INLINE struct vec4 svec4_multiply_mat4(struct vec4 a, struct mat4 m)
3368 {
3369 struct vec4 result;
3370 vec4_multiply_mat4((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&m);
3371 return result;
3372 }
3373
svec4_divide(struct vec4 a,struct vec4 b)3374 MATHC_INLINE struct vec4 svec4_divide(struct vec4 a, struct vec4 b)
3375 {
3376 struct vec4 result;
3377 vec4_divide((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3378 return result;
3379 }
3380
svec4_snap(struct vec4 a,struct vec4 b)3381 MATHC_INLINE struct vec4 svec4_snap(struct vec4 a, struct vec4 b)
3382 {
3383 struct vec4 result;
3384 vec4_snap((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3385 return result;
3386 }
3387
svec4_negative(struct vec4 a)3388 MATHC_INLINE struct vec4 svec4_negative(struct vec4 a)
3389 {
3390 struct vec4 result;
3391 vec4_negative((mfloat_t *)&result, (mfloat_t *)&a);
3392 return result;
3393 }
3394
svec4_inverse(struct vec4 a)3395 MATHC_INLINE struct vec4 svec4_inverse(struct vec4 a)
3396 {
3397 struct vec4 result;
3398 vec4_inverse((mfloat_t *)&result, (mfloat_t *)&a);
3399 return result;
3400 }
3401
svec4_abs(struct vec4 a)3402 MATHC_INLINE struct vec4 svec4_abs(struct vec4 a)
3403 {
3404 struct vec4 result;
3405 vec4_abs((mfloat_t *)&result, (mfloat_t *)&a);
3406 return result;
3407 }
3408
svec4_floor(struct vec4 a)3409 MATHC_INLINE struct vec4 svec4_floor(struct vec4 a)
3410 {
3411 struct vec4 result;
3412 vec4_floor((mfloat_t *)&result, (mfloat_t *)&a);
3413 return result;
3414 }
3415
svec4_ceil(struct vec4 a)3416 MATHC_INLINE struct vec4 svec4_ceil(struct vec4 a)
3417 {
3418 struct vec4 result;
3419 vec4_ceil((mfloat_t *)&result, (mfloat_t *)&a);
3420 return result;
3421 }
3422
svec4_round(struct vec4 a)3423 MATHC_INLINE struct vec4 svec4_round(struct vec4 a)
3424 {
3425 struct vec4 result;
3426 vec4_round((mfloat_t *)&result, (mfloat_t *)&a);
3427 return result;
3428 }
3429
svec4_max(struct vec4 a,struct vec4 b)3430 MATHC_INLINE struct vec4 svec4_max(struct vec4 a, struct vec4 b)
3431 {
3432 struct vec4 result;
3433 vec4_max((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3434 return result;
3435 }
3436
svec4_min(struct vec4 a,struct vec4 b)3437 MATHC_INLINE struct vec4 svec4_min(struct vec4 a, struct vec4 b)
3438 {
3439 struct vec4 result;
3440 vec4_min((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3441 return result;
3442 }
3443
svec4_clamp(struct vec4 a,struct vec4 lower,struct vec4 higher)3444 MATHC_INLINE struct vec4 svec4_clamp(struct vec4 a, struct vec4 lower, struct vec4 higher)
3445 {
3446 struct vec4 result;
3447 vec4_clamp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&lower, (mfloat_t *)&higher);
3448 return result;
3449 }
3450
svec4_normalize(struct vec4 a)3451 MATHC_INLINE struct vec4 svec4_normalize(struct vec4 a)
3452 {
3453 struct vec4 result;
3454 vec4_normalize((mfloat_t *)&result, (mfloat_t *)&a);
3455 return result;
3456 }
3457
svec4_lerp(struct vec4 a,struct vec4 b,mfloat_t p)3458 MATHC_INLINE struct vec4 svec4_lerp(struct vec4 a, struct vec4 b, mfloat_t p)
3459 {
3460 struct vec4 result;
3461 vec4_lerp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, p);
3462 return result;
3463 }
3464
3465 /* Vector 4D Integer */
svec4i_is_zero(struct vec4i a)3466 MATHC_INLINE bool svec4i_is_zero(struct vec4i a)
3467 {
3468 return vec4i_is_zero((mint_t *)&a);
3469 }
3470
svec4i_is_equal(struct vec4i a,struct vec4i b)3471 MATHC_INLINE bool svec4i_is_equal(struct vec4i a, struct vec4i b)
3472 {
3473 return vec4i_is_equal((mint_t *)&a, (mint_t *)&b);
3474 }
3475
svec4i(mint_t x,mint_t y,mint_t z,mint_t w)3476 MATHC_INLINE struct vec4i svec4i(mint_t x, mint_t y, mint_t z, mint_t w)
3477 {
3478 struct vec4i result;
3479 vec4i((mint_t *)&result, x, y, z, w);
3480 return result;
3481 }
3482
svec4i_assign(struct vec4i a)3483 MATHC_INLINE struct vec4i svec4i_assign(struct vec4i a)
3484 {
3485 struct vec4i result;
3486 vec4i_assign((mint_t *)&result, (mint_t *)&a);
3487 return result;
3488 }
3489
svec4i_assign_vec4(struct vec4 a)3490 MATHC_INLINE struct vec4i svec4i_assign_vec4(struct vec4 a)
3491 {
3492 struct vec4i result;
3493 vec4i_assign_vec4((mint_t *)&result, (mfloat_t *)&a);
3494 return result;
3495 }
3496
svec4i_zero(void)3497 MATHC_INLINE struct vec4i svec4i_zero(void)
3498 {
3499 struct vec4i result;
3500 vec4i_zero((mint_t *)&result);
3501 return result;
3502 }
3503
svec4i_one(void)3504 MATHC_INLINE struct vec4i svec4i_one(void)
3505 {
3506 struct vec4i result;
3507 vec4i_one((mint_t *)&result);
3508 return result;
3509 }
3510
svec4i_add(struct vec4i a,struct vec4i b)3511 MATHC_INLINE struct vec4i svec4i_add(struct vec4i a, struct vec4i b)
3512 {
3513 struct vec4i result;
3514 vec4i_add((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3515 return result;
3516 }
3517
svec4i_subtract(struct vec4i a,struct vec4i b)3518 MATHC_INLINE struct vec4i svec4i_subtract(struct vec4i a, struct vec4i b)
3519 {
3520 struct vec4i result;
3521 vec4i_subtract((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3522 return result;
3523 }
3524
svec4i_scale(struct vec4i a,mfloat_t scalar)3525 MATHC_INLINE struct vec4i svec4i_scale(struct vec4i a, mfloat_t scalar)
3526 {
3527 struct vec4i result;
3528 vec4i_scale((mint_t *)&result, (mint_t *)&a, scalar);
3529 return result;
3530 }
3531
svec4i_multiply(struct vec4i a,struct vec4i b)3532 MATHC_INLINE struct vec4i svec4i_multiply(struct vec4i a, struct vec4i b)
3533 {
3534 struct vec4i result;
3535 vec4i_multiply((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3536 return result;
3537 }
3538
svec4i_multiply_mat4(struct vec4i a,struct mat4 m)3539 MATHC_INLINE struct vec4i svec4i_multiply_mat4(struct vec4i a, struct mat4 m)
3540 {
3541 struct vec4i result;
3542 vec4i_multiply_mat4((mint_t *)&result, (mint_t *)&a, (mfloat_t *)&m);
3543 return result;
3544 }
3545
svec4i_divide(struct vec4i a,struct vec4i b)3546 MATHC_INLINE struct vec4i svec4i_divide(struct vec4i a, struct vec4i b)
3547 {
3548 struct vec4i result;
3549 vec4i_divide((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3550 return result;
3551 }
3552
svec4i_snap(struct vec4i a,struct vec4i b)3553 MATHC_INLINE struct vec4i svec4i_snap(struct vec4i a, struct vec4i b)
3554 {
3555 struct vec4i result;
3556 vec4i_snap((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3557 return result;
3558 }
3559
svec4i_negative(struct vec4i a)3560 MATHC_INLINE struct vec4i svec4i_negative(struct vec4i a)
3561 {
3562 struct vec4i result;
3563 vec4i_negative((mint_t *)&result, (mint_t *)&a);
3564 return result;
3565 }
3566
svec4i_inverse(struct vec4i a)3567 MATHC_INLINE struct vec4i svec4i_inverse(struct vec4i a)
3568 {
3569 struct vec4i result;
3570 vec4i_inverse((mint_t *)&result, (mint_t *)&a);
3571 return result;
3572 }
3573
svec4i_abs(struct vec4i a)3574 MATHC_INLINE struct vec4i svec4i_abs(struct vec4i a)
3575 {
3576 struct vec4i result;
3577 vec4i_abs((mint_t *)&result, (mint_t *)&a);
3578 return result;
3579 }
3580
svec4i_floor(struct vec4 a)3581 MATHC_INLINE struct vec4i svec4i_floor(struct vec4 a)
3582 {
3583 struct vec4i result;
3584 vec4i_floor((mint_t *)&result, (mfloat_t *)&a);
3585 return result;
3586 }
3587
svec4i_ceil(struct vec4 a)3588 MATHC_INLINE struct vec4i svec4i_ceil(struct vec4 a)
3589 {
3590 struct vec4i result;
3591 vec4i_ceil((mint_t *)&result, (mfloat_t *)&a);
3592 return result;
3593 }
3594
svec4i_round(struct vec4 a)3595 MATHC_INLINE struct vec4i svec4i_round(struct vec4 a)
3596 {
3597 struct vec4i result;
3598 vec4i_round((mint_t *)&result, (mfloat_t *)&a);
3599 return result;
3600 }
3601
svec4i_max(struct vec4i a,struct vec4i b)3602 MATHC_INLINE struct vec4i svec4i_max(struct vec4i a, struct vec4i b)
3603 {
3604 struct vec4i result;
3605 vec4i_max((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3606 return result;
3607 }
3608
svec4i_min(struct vec4i a,struct vec4i b)3609 MATHC_INLINE struct vec4i svec4i_min(struct vec4i a, struct vec4i b)
3610 {
3611 struct vec4i result;
3612 vec4i_min((mint_t *)&result, (mint_t *)&a, (mint_t *)&b);
3613 return result;
3614 }
3615
svec4i_clamp(struct vec4i a,struct vec4i lower,struct vec4i higher)3616 MATHC_INLINE struct vec4i svec4i_clamp(struct vec4i a, struct vec4i lower, struct vec4i higher)
3617 {
3618 struct vec4i result;
3619 vec4i_clamp((mint_t *)&result, (mint_t *)&a, (mint_t *)&lower, (mint_t *)&higher);
3620 return result;
3621 }
3622
svec4i_normalize(struct vec4i a)3623 MATHC_INLINE struct vec4i svec4i_normalize(struct vec4i a)
3624 {
3625 struct vec4i result;
3626 vec4i_normalize((mint_t *)&result, (mint_t *)&a);
3627 return result;
3628 }
3629
svec4i_lerp(struct vec4i a,struct vec4i b,mfloat_t p)3630 MATHC_INLINE struct vec4i svec4i_lerp(struct vec4i a, struct vec4i b, mfloat_t p)
3631 {
3632 struct vec4i result;
3633 vec4i_lerp((mint_t *)&result, (mint_t *)&a, (mint_t *)&b, p);
3634 return result;
3635 }
3636
3637 /* Quaternion */
squat_is_zero(struct quat a)3638 MATHC_INLINE bool squat_is_zero(struct quat a)
3639 {
3640 return quat_is_zero((mfloat_t *)&a);
3641 }
3642
squat_is_near_zero(struct quat a,mfloat_t epsilon)3643 MATHC_INLINE bool squat_is_near_zero(struct quat a, mfloat_t epsilon)
3644 {
3645 return quat_is_near_zero((mfloat_t *)&a, epsilon);
3646 }
3647
squat_is_equal(struct quat a,struct quat b)3648 MATHC_INLINE bool squat_is_equal(struct quat a, struct quat b)
3649 {
3650 return quat_is_equal((mfloat_t *)&a, (mfloat_t *)&b);
3651 }
3652
squat_is_nearly_equal(struct quat a,struct quat b,mfloat_t epsilon)3653 MATHC_INLINE bool squat_is_nearly_equal(struct quat a, struct quat b, mfloat_t epsilon)
3654 {
3655 return quat_is_nearly_equal((mfloat_t *)&a, (mfloat_t *)&b, epsilon);
3656 }
3657
squat(mfloat_t x,mfloat_t y,mfloat_t z,mfloat_t w)3658 MATHC_INLINE struct quat squat(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
3659 {
3660 struct quat result;
3661 quat((mfloat_t *)&result, x, y, z, w);
3662 return result;
3663 }
3664
squat_assign(struct quat a)3665 MATHC_INLINE struct quat squat_assign(struct quat a)
3666 {
3667 struct quat result;
3668 quat_assign((mfloat_t *)&result, (mfloat_t *)&a);
3669 return result;
3670 }
3671
squat_zero(void)3672 MATHC_INLINE struct quat squat_zero(void)
3673 {
3674 struct quat result;
3675 quat_zero((mfloat_t *)&result);
3676 return result;
3677 }
3678
squat_null(void)3679 MATHC_INLINE struct quat squat_null(void)
3680 {
3681 struct quat result;
3682 quat_null((mfloat_t *)&result);
3683 return result;
3684 }
3685
squat_scale(struct quat a,mfloat_t scalar)3686 MATHC_INLINE struct quat squat_scale(struct quat a, mfloat_t scalar)
3687 {
3688 struct quat result;
3689 quat_scale((mfloat_t *)&result, (mfloat_t *)&a, scalar);
3690 return result;
3691 }
3692
squat_multiply(struct quat a,struct quat b)3693 MATHC_INLINE struct quat squat_multiply(struct quat a, struct quat b)
3694 {
3695 struct quat result;
3696 quat_multiply((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3697 return result;
3698 }
3699
squat_divide(struct quat a,struct quat b)3700 MATHC_INLINE struct quat squat_divide(struct quat a, struct quat b)
3701 {
3702 struct quat result;
3703 quat_divide((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3704 return result;
3705 }
3706
squat_negative(struct quat a)3707 MATHC_INLINE struct quat squat_negative(struct quat a)
3708 {
3709 struct quat result;
3710 quat_negative((mfloat_t *)&result, (mfloat_t *)&a);
3711 return result;
3712 }
3713
squat_conjugate(struct quat a)3714 MATHC_INLINE struct quat squat_conjugate(struct quat a)
3715 {
3716 struct quat result;
3717 quat_conjugate((mfloat_t *)&result, (mfloat_t *)&a);
3718 return result;
3719 }
3720
squat_inverse(struct quat a)3721 MATHC_INLINE struct quat squat_inverse(struct quat a)
3722 {
3723 struct quat result;
3724 quat_inverse((mfloat_t *)&result, (mfloat_t *)&a);
3725 return result;
3726 }
3727
squat_normalize(struct quat a)3728 MATHC_INLINE struct quat squat_normalize(struct quat a)
3729 {
3730 struct quat result;
3731 quat_normalize((mfloat_t *)&result, (mfloat_t *)&a);
3732 return result;
3733 }
3734
squat_power(struct quat a,mfloat_t exponent)3735 MATHC_INLINE struct quat squat_power(struct quat a, mfloat_t exponent)
3736 {
3737 struct quat result;
3738 quat_power((mfloat_t *)&result, (mfloat_t *)&a, exponent);
3739 return result;
3740 }
3741
squat_from_axis_angle(struct vec3 a,mfloat_t angle)3742 MATHC_INLINE struct quat squat_from_axis_angle(struct vec3 a, mfloat_t angle)
3743 {
3744 struct quat result;
3745 quat_from_axis_angle((mfloat_t *)&result, (mfloat_t *)&a, angle);
3746 return result;
3747 }
3748
squat_from_vec3(struct vec3 a,struct vec3 b)3749 MATHC_INLINE struct quat squat_from_vec3(struct vec3 a, struct vec3 b)
3750 {
3751 struct quat result;
3752 quat_from_vec3((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3753 return result;
3754 }
3755
squat_from_mat4(struct mat4 a)3756 MATHC_INLINE struct quat squat_from_mat4(struct mat4 a)
3757 {
3758 struct quat result;
3759 quat_from_mat4((mfloat_t *)&result, (mfloat_t *)&a);
3760 return result;
3761 }
3762
squat_from_yaw_pitch_roll(mfloat_t yaw,mfloat_t pitch,mfloat_t roll)3763 MATHC_INLINE struct quat squat_from_yaw_pitch_roll(mfloat_t yaw, mfloat_t pitch, mfloat_t roll)
3764 {
3765 struct quat result;
3766 quat_from_yaw_pitch_roll((mfloat_t *)&result, yaw, pitch, roll);
3767 return result;
3768 }
3769
squat_lerp(struct quat a,struct quat b,mfloat_t p)3770 MATHC_INLINE struct quat squat_lerp(struct quat a, struct quat b, mfloat_t p)
3771 {
3772 struct quat result;
3773 quat_lerp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, p);
3774 return result;
3775 }
3776
squat_slerp(struct quat a,struct quat b,mfloat_t p)3777 MATHC_INLINE struct quat squat_slerp(struct quat a, struct quat b, mfloat_t p)
3778 {
3779 struct quat result;
3780 quat_slerp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, p);
3781 return result;
3782 }
3783
squat_dot(struct quat a,struct quat b)3784 MATHC_INLINE mfloat_t squat_dot(struct quat a, struct quat b)
3785 {
3786 return quat_dot((mfloat_t *)&a, (mfloat_t *)&b);
3787 }
3788
squat_angle(struct quat a,struct quat b)3789 MATHC_INLINE mfloat_t squat_angle(struct quat a, struct quat b)
3790 {
3791 return quat_angle((mfloat_t *)&a, (mfloat_t *)&b);
3792 }
3793
squat_length(struct quat a)3794 MATHC_INLINE mfloat_t squat_length(struct quat a)
3795 {
3796 return quat_length((mfloat_t *)&a);
3797 }
3798
squat_length_squared(struct quat a)3799 MATHC_INLINE mfloat_t squat_length_squared(struct quat a)
3800 {
3801 return quat_length_squared((mfloat_t *)&a);
3802 }
3803
3804 /* Matrix 2x2 */
smat2(mfloat_t m11,mfloat_t m12,mfloat_t m21,mfloat_t m22)3805 MATHC_INLINE struct mat2 smat2(
3806 mfloat_t m11, mfloat_t m12,
3807 mfloat_t m21, mfloat_t m22)
3808 {
3809 struct mat2 result;
3810 mat2((mfloat_t *)&result,
3811 m11, m12,
3812 m21, m22);
3813 return result;
3814 }
3815
smat2_zero(void)3816 MATHC_INLINE struct mat2 smat2_zero(void)
3817 {
3818 struct mat2 result;
3819 mat2_zero((mfloat_t *)&result);
3820 return result;
3821 }
3822
smat2_identity(void)3823 MATHC_INLINE struct mat2 smat2_identity(void)
3824 {
3825 struct mat2 result;
3826 mat2_identity((mfloat_t *)&result);
3827 return result;
3828 }
3829
smat2_determinant(struct mat2 m)3830 MATHC_INLINE mfloat_t smat2_determinant(struct mat2 m)
3831 {
3832 return mat2_determinant((mfloat_t *)&m);
3833 }
3834
smat2_assign(struct mat2 m)3835 MATHC_INLINE struct mat2 smat2_assign(struct mat2 m)
3836 {
3837 struct mat2 result;
3838 mat2_assign((mfloat_t *)&result, (mfloat_t *)&m);
3839 return result;
3840 }
3841
smat2_assign_mat3(struct mat3 m)3842 MATHC_INLINE struct mat2 smat2_assign_mat3(struct mat3 m)
3843 {
3844 struct mat2 result;
3845 mat2_assign_mat3((mfloat_t *)&result, (mfloat_t *)&m);
3846 return result;
3847 }
3848
smat2_assign_mat4(struct mat4 m)3849 MATHC_INLINE struct mat2 smat2_assign_mat4(struct mat4 m)
3850 {
3851 struct mat2 result;
3852 mat2_assign_mat4((mfloat_t *)&result, (mfloat_t *)&m);
3853 return result;
3854 }
3855
smat2_transpose(struct mat2 m)3856 MATHC_INLINE struct mat2 smat2_transpose(struct mat2 m)
3857 {
3858 struct mat2 result;
3859 mat2_transpose((mfloat_t *)&result, (mfloat_t *)&m);
3860 return result;
3861 }
3862
smat2_cofactor(struct mat2 m)3863 MATHC_INLINE struct mat2 smat2_cofactor(struct mat2 m)
3864 {
3865 struct mat2 result;
3866 mat2_cofactor((mfloat_t *)&result, (mfloat_t *)&m);
3867 return result;
3868 }
3869
smat2_inverse(struct mat2 m)3870 MATHC_INLINE struct mat2 smat2_inverse(struct mat2 m)
3871 {
3872 struct mat2 result;
3873 mat2_inverse((mfloat_t *)&result, (mfloat_t *)&m);
3874 return result;
3875 }
3876
smat2_rotation(mfloat_t angle)3877 MATHC_INLINE struct mat2 smat2_rotation(mfloat_t angle)
3878 {
3879 struct mat2 result;
3880 mat2_rotation((mfloat_t *)&result, angle);
3881 return result;
3882 }
3883
smat2_scaling(struct mat2 v)3884 MATHC_INLINE struct mat2 smat2_scaling(struct mat2 v)
3885 {
3886 struct mat2 result;
3887 mat2_scaling((mfloat_t *)&result, (mfloat_t *)&v);
3888 return result;
3889 }
3890
smat2_negative(struct mat2 m)3891 MATHC_INLINE struct mat2 smat2_negative(struct mat2 m)
3892 {
3893 struct mat2 result;
3894 mat2_negative((mfloat_t *)&result, (mfloat_t *)&m);
3895 return result;
3896 }
3897
smat2_scale(struct mat2 m,mfloat_t s)3898 MATHC_INLINE struct mat2 smat2_scale(struct mat2 m, mfloat_t s)
3899 {
3900 struct mat2 result;
3901 mat2_scale((mfloat_t *)&result, (mfloat_t *)&m, s);
3902 return result;
3903 }
3904
smat2_multiply(struct mat2 a,struct mat2 b)3905 MATHC_INLINE struct mat2 smat2_multiply(struct mat2 a, struct mat2 b)
3906 {
3907 struct mat2 result;
3908 mat2_multiply((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
3909 return result;
3910 }
3911
smat2_lerp(struct mat2 a,struct mat2 b,mfloat_t p)3912 MATHC_INLINE struct mat2 smat2_lerp(struct mat2 a, struct mat2 b, mfloat_t p)
3913 {
3914 struct mat2 result;
3915 mat2_lerp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, p);
3916 return result;
3917 }
3918
3919 /* Matrix 3x3 */
smat3(mfloat_t m11,mfloat_t m12,mfloat_t m13,mfloat_t m21,mfloat_t m22,mfloat_t m23,mfloat_t m31,mfloat_t m32,mfloat_t m33)3920 MATHC_INLINE struct mat3 smat3(
3921 mfloat_t m11, mfloat_t m12, mfloat_t m13,
3922 mfloat_t m21, mfloat_t m22, mfloat_t m23,
3923 mfloat_t m31, mfloat_t m32, mfloat_t m33)
3924 {
3925 struct mat3 result;
3926 mat3((mfloat_t *)&result,
3927 m11, m12, m13,
3928 m21, m22, m23,
3929 m31, m32, m33);
3930 return result;
3931 }
3932
smat3_zero(void)3933 MATHC_INLINE struct mat3 smat3_zero(void)
3934 {
3935 struct mat3 result;
3936 mat3_zero((mfloat_t *)&result);
3937 return result;
3938 }
3939
smat3_identity(void)3940 MATHC_INLINE struct mat3 smat3_identity(void)
3941 {
3942 struct mat3 result;
3943 mat3_identity((mfloat_t *)&result);
3944 return result;
3945 }
3946
smat3_determinant(struct mat3 m)3947 MATHC_INLINE mfloat_t smat3_determinant(struct mat3 m)
3948 {
3949 return mat3_determinant((mfloat_t *)&m);
3950 }
3951
smat3_assign(struct mat3 m)3952 MATHC_INLINE struct mat3 smat3_assign(struct mat3 m)
3953 {
3954 struct mat3 result;
3955 mat3_assign((mfloat_t *)&result, (mfloat_t *)&m);
3956 return result;
3957 }
3958
smat3_assign_mat2(struct mat2 m)3959 MATHC_INLINE struct mat3 smat3_assign_mat2(struct mat2 m)
3960 {
3961 struct mat3 result;
3962 mat3_assign_mat2((mfloat_t *)&result, (mfloat_t *)&m);
3963 return result;
3964 }
3965
smat3_assign_mat4(struct mat4 m)3966 MATHC_INLINE struct mat3 smat3_assign_mat4(struct mat4 m)
3967 {
3968 struct mat3 result;
3969 mat3_assign_mat4((mfloat_t *)&result, (mfloat_t *)&m);
3970 return result;
3971 }
3972
smat3_transpose(struct mat3 m)3973 MATHC_INLINE struct mat3 smat3_transpose(struct mat3 m)
3974 {
3975 struct mat3 result;
3976 mat3_transpose((mfloat_t *)&result, (mfloat_t *)&m);
3977 return result;
3978 }
3979
smat3_cofactor(struct mat3 m)3980 MATHC_INLINE struct mat3 smat3_cofactor(struct mat3 m)
3981 {
3982 struct mat3 result;
3983 mat3_cofactor((mfloat_t *)&result, (mfloat_t *)&m);
3984 return result;
3985 }
3986
smat3_adjugate(struct mat3 m)3987 MATHC_INLINE struct mat3 smat3_adjugate(struct mat3 m)
3988 {
3989 struct mat3 result;
3990 mat3_adjugate((mfloat_t *)&result, (mfloat_t *)&m);
3991 return result;
3992 }
3993
smat3_inverse(struct mat3 m)3994 MATHC_INLINE struct mat3 smat3_inverse(struct mat3 m)
3995 {
3996 struct mat3 result;
3997 mat3_inverse((mfloat_t *)&result, (mfloat_t *)&m);
3998 return result;
3999 }
4000
smat3_rotation_x(mfloat_t angle)4001 MATHC_INLINE struct mat3 smat3_rotation_x(mfloat_t angle)
4002 {
4003 struct mat3 result;
4004 mat3_rotation_x((mfloat_t *)&result, angle);
4005 return result;
4006 }
4007
smat3_rotation_y(mfloat_t angle)4008 MATHC_INLINE struct mat3 smat3_rotation_y(mfloat_t angle)
4009 {
4010 struct mat3 result;
4011 mat3_rotation_y((mfloat_t *)&result, angle);
4012 return result;
4013 }
4014
smat3_rotation_z(mfloat_t angle)4015 MATHC_INLINE struct mat3 smat3_rotation_z(mfloat_t angle)
4016 {
4017 struct mat3 result;
4018 mat3_rotation_z((mfloat_t *)&result, angle);
4019 return result;
4020 }
4021
smat3_rotation_axis(struct vec3 a,mfloat_t angle)4022 MATHC_INLINE struct mat3 smat3_rotation_axis(struct vec3 a, mfloat_t angle)
4023 {
4024 struct mat3 result;
4025 mat3_rotation_axis((mfloat_t *)&result, (mfloat_t *)&a, angle);
4026 return result;
4027 }
4028
smat3_rotation_quaternion(struct quat q)4029 MATHC_INLINE struct mat3 smat3_rotation_quaternion(struct quat q)
4030 {
4031 struct mat3 result;
4032 mat3_rotation_quaternion((mfloat_t *)&result, (mfloat_t *)&q);
4033 return result;
4034 }
4035
smat3_scaling(struct mat3 v)4036 MATHC_INLINE struct mat3 smat3_scaling(struct mat3 v)
4037 {
4038 struct mat3 result;
4039 mat3_scaling((mfloat_t *)&result, (mfloat_t *)&v);
4040 return result;
4041 }
4042
smat3_negative(struct mat3 m)4043 MATHC_INLINE struct mat3 smat3_negative(struct mat3 m)
4044 {
4045 struct mat3 result;
4046 mat3_negative((mfloat_t *)&result, (mfloat_t *)&m);
4047 return result;
4048 }
4049
smat3_scale(struct mat4 m,mfloat_t s)4050 MATHC_INLINE struct mat3 smat3_scale(struct mat4 m, mfloat_t s)
4051 {
4052 struct mat3 result;
4053 mat3_scale((mfloat_t *)&result, (mfloat_t *)&m, s);
4054 return result;
4055 }
4056
smat3_multiply(struct mat3 a,struct mat3 b)4057 MATHC_INLINE struct mat3 smat3_multiply(struct mat3 a, struct mat3 b)
4058 {
4059 struct mat3 result;
4060 mat3_multiply((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
4061 return result;
4062 }
4063
smat3_lerp(struct mat3 a,struct mat3 b,mfloat_t p)4064 MATHC_INLINE struct mat3 smat3_lerp(struct mat3 a, struct mat3 b, mfloat_t p)
4065 {
4066 struct mat3 result;
4067 mat3_lerp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, p);
4068 return result;
4069 }
4070
4071 /* Matrix 4x4 */
smat4(mfloat_t m11,mfloat_t m12,mfloat_t m13,mfloat_t m14,mfloat_t m21,mfloat_t m22,mfloat_t m23,mfloat_t m24,mfloat_t m31,mfloat_t m32,mfloat_t m33,mfloat_t m34,mfloat_t m41,mfloat_t m42,mfloat_t m43,mfloat_t m44)4072 MATHC_INLINE struct mat4 smat4(
4073 mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14,
4074 mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24,
4075 mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34,
4076 mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44)
4077 {
4078 struct mat4 result;
4079 mat4((mfloat_t *)&result,
4080 m11, m12, m13, m14,
4081 m21, m22, m23, m24,
4082 m31, m32, m33, m34,
4083 m41, m42, m43, m44);
4084 return result;
4085 }
4086
smat4_zero(void)4087 MATHC_INLINE struct mat4 smat4_zero(void)
4088 {
4089 struct mat4 result;
4090 mat4_zero((mfloat_t *)&result);
4091 return result;
4092 }
4093
smat4_identity(void)4094 MATHC_INLINE struct mat4 smat4_identity(void)
4095 {
4096 struct mat4 result;
4097 mat4_identity((mfloat_t *)&result);
4098 return result;
4099 }
4100
smat4_determinant(struct mat4 m)4101 MATHC_INLINE mfloat_t smat4_determinant(struct mat4 m)
4102 {
4103 return mat4_determinant((mfloat_t *)&m);
4104 }
4105
smat4_assign(struct mat4 m)4106 MATHC_INLINE struct mat4 smat4_assign(struct mat4 m)
4107 {
4108 struct mat4 result;
4109 mat4_assign((mfloat_t *)&result, (mfloat_t *)&m);
4110 return result;
4111 }
4112
smat4_assign_mat2(struct mat2 m)4113 MATHC_INLINE struct mat4 smat4_assign_mat2(struct mat2 m)
4114 {
4115 struct mat4 result;
4116 mat4_assign_mat2((mfloat_t *)&result, (mfloat_t *)&m);
4117 return result;
4118 }
4119
smat4_assign_mat3(struct mat3 m)4120 MATHC_INLINE struct mat4 smat4_assign_mat3(struct mat3 m)
4121 {
4122 struct mat4 result;
4123 mat4_assign_mat3((mfloat_t *)&result, (mfloat_t *)&m);
4124 return result;
4125 }
4126
smat4_transpose(struct mat4 m)4127 MATHC_INLINE struct mat4 smat4_transpose(struct mat4 m)
4128 {
4129 struct mat4 result;
4130 mat4_transpose((mfloat_t *)&result, (mfloat_t *)&m);
4131 return result;
4132 }
4133
smat4_adjugate(struct mat4 m)4134 MATHC_INLINE struct mat4 smat4_adjugate(struct mat4 m)
4135 {
4136 struct mat4 result;
4137 mat4_adjugate((mfloat_t *)&result, (mfloat_t *)&m);
4138 return result;
4139 }
4140
smat4_inverse(struct mat4 m)4141 MATHC_INLINE struct mat4 smat4_inverse(struct mat4 m)
4142 {
4143 struct mat4 result;
4144 mat4_inverse((mfloat_t *)&result, (mfloat_t *)&m);
4145 return result;
4146 }
4147
smat4_ortho(mfloat_t l,mfloat_t r,mfloat_t b,mfloat_t t,mfloat_t n,mfloat_t f)4148 MATHC_INLINE struct mat4 smat4_ortho(mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f)
4149 {
4150 struct mat4 result;
4151 mat4_ortho((mfloat_t *)&result, l, r, b, t, n, f);
4152 return result;
4153 }
4154
smat4_perspective(mfloat_t fov_y,mfloat_t aspect,mfloat_t n,mfloat_t f)4155 MATHC_INLINE struct mat4 smat4_perspective(mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f)
4156 {
4157 struct mat4 result;
4158 mat4_perspective((mfloat_t *)&result, fov_y, aspect, n, f);
4159 return result;
4160 }
4161
smat4_perspective_fov(mfloat_t fov,mfloat_t w,mfloat_t h,mfloat_t n,mfloat_t f)4162 MATHC_INLINE struct mat4 smat4_perspective_fov(mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f)
4163 {
4164 struct mat4 result;
4165 mat4_perspective_fov((mfloat_t *)&result, fov, w, h, n, f);
4166 return result;
4167 }
4168
smat4_perspective_infinite(mfloat_t fov_y,mfloat_t aspect,mfloat_t n)4169 MATHC_INLINE struct mat4 smat4_perspective_infinite(mfloat_t fov_y, mfloat_t aspect, mfloat_t n)
4170 {
4171 struct mat4 result;
4172 mat4_perspective_infinite((mfloat_t *)&result, fov_y, aspect, n);
4173 return result;
4174 }
4175
smat4_rotation_x(mfloat_t angle)4176 MATHC_INLINE struct mat4 smat4_rotation_x(mfloat_t angle)
4177 {
4178 struct mat4 result;
4179 mat4_rotation_x((mfloat_t *)&result, angle);
4180 return result;
4181 }
4182
smat4_rotation_y(mfloat_t angle)4183 MATHC_INLINE struct mat4 smat4_rotation_y(mfloat_t angle)
4184 {
4185 struct mat4 result;
4186 mat4_rotation_y((mfloat_t *)&result, angle);
4187 return result;
4188 }
4189
smat4_rotation_z(mfloat_t angle)4190 MATHC_INLINE struct mat4 smat4_rotation_z(mfloat_t angle)
4191 {
4192 struct mat4 result;
4193 mat4_rotation_z((mfloat_t *)&result, angle);
4194 return result;
4195 }
4196
smat4_rotation_axis(struct mat4 a,mfloat_t angle)4197 MATHC_INLINE struct mat4 smat4_rotation_axis(struct mat4 a, mfloat_t angle)
4198 {
4199 struct mat4 result;
4200 mat4_rotation_axis((mfloat_t *)&result, (mfloat_t *)&a, angle);
4201 return result;
4202 }
4203
smat4_rotation_quaternion(struct mat4 q)4204 MATHC_INLINE struct mat4 smat4_rotation_quaternion(struct mat4 q)
4205 {
4206 struct mat4 result;
4207 mat4_rotation_quaternion((mfloat_t *)&result, (mfloat_t *)&q);
4208 return result;
4209 }
4210
smat4_look_at(struct vec3 position,struct vec3 target,struct vec3 up_axis)4211 MATHC_INLINE struct mat4 smat4_look_at(struct vec3 position, struct vec3 target, struct vec3 up_axis)
4212 {
4213 struct mat4 result;
4214 mat4_look_at((mfloat_t *)&result, (mfloat_t *)&position, (mfloat_t *)&target, (mfloat_t *)&up_axis);
4215 return result;
4216 }
4217
smat4_translation(struct mat4 v)4218 MATHC_INLINE struct mat4 smat4_translation(struct mat4 v)
4219 {
4220 struct mat4 result;
4221 mat4_translation((mfloat_t *)&result, (mfloat_t *)&v);
4222 return result;
4223 }
4224
smat4_scaling(struct mat4 v)4225 MATHC_INLINE struct mat4 smat4_scaling(struct mat4 v)
4226 {
4227 struct mat4 result;
4228 mat4_scaling((mfloat_t *)&result, (mfloat_t *)&v);
4229 return result;
4230 }
4231
smat4_negative(struct mat4 m)4232 MATHC_INLINE struct mat4 smat4_negative(struct mat4 m)
4233 {
4234 struct mat4 result;
4235 mat4_negative((mfloat_t *)&result, (mfloat_t *)&m);
4236 return result;
4237 }
4238
smat4_scale(struct mat4 m,mfloat_t s)4239 MATHC_INLINE struct mat4 smat4_scale(struct mat4 m, mfloat_t s)
4240 {
4241 struct mat4 result;
4242 mat4_scale((mfloat_t *)&result, (mfloat_t *)&m, s);
4243 return result;
4244 }
4245
smat4_multiply(struct mat4 a,struct mat4 b)4246 MATHC_INLINE struct mat4 smat4_multiply(struct mat4 a, struct mat4 b)
4247 {
4248 struct mat4 result;
4249 mat4_multiply((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b);
4250 return result;
4251 }
4252
smat4_lerp(struct mat4 a,struct mat4 b,mfloat_t p)4253 MATHC_INLINE struct mat4 smat4_lerp(struct mat4 a, struct mat4 b, mfloat_t p)
4254 {
4255 struct mat4 result;
4256 mat4_lerp((mfloat_t *)&result, (mfloat_t *)&a, (mfloat_t *)&b, p);
4257 return result;
4258 }
4259 #endif
4260
4261 #ifndef MATHC_NO_EASING_FUNCTIONS
4262 /* Easing functions */
4263 mfloat_t quadratic_ease_in(mfloat_t p);
4264 mfloat_t quadratic_ease_out(mfloat_t p);
4265 mfloat_t quadratic_ease_in_out(mfloat_t p);
4266 mfloat_t cubic_ease_in(mfloat_t p);
4267 mfloat_t cubic_ease_out(mfloat_t p);
4268 mfloat_t cubic_ease_in_out(mfloat_t p);
4269 mfloat_t quartic_ease_in(mfloat_t p);
4270 mfloat_t quartic_ease_out(mfloat_t p);
4271 mfloat_t quartic_ease_in_out(mfloat_t p);
4272 mfloat_t quintic_ease_in(mfloat_t p);
4273 mfloat_t quintic_ease_out(mfloat_t p);
4274 mfloat_t quintic_ease_in_out(mfloat_t p);
4275 mfloat_t sine_ease_in(mfloat_t p);
4276 mfloat_t sine_ease_out(mfloat_t p);
4277 mfloat_t sine_ease_in_out(mfloat_t p);
4278 mfloat_t circular_ease_in(mfloat_t p);
4279 mfloat_t circular_ease_out(mfloat_t p);
4280 mfloat_t circular_ease_in_out(mfloat_t p);
4281 mfloat_t exponential_ease_in(mfloat_t p);
4282 mfloat_t exponential_ease_out(mfloat_t p);
4283 mfloat_t exponential_ease_in_out(mfloat_t p);
4284 mfloat_t elastic_ease_in(mfloat_t p);
4285 mfloat_t elastic_ease_out(mfloat_t p);
4286 mfloat_t elastic_ease_in_out(mfloat_t p);
4287 mfloat_t back_ease_in(mfloat_t p);
4288 mfloat_t back_ease_out(mfloat_t p);
4289 mfloat_t back_ease_in_out(mfloat_t p);
4290 mfloat_t bounce_ease_in(mfloat_t p);
4291 mfloat_t bounce_ease_out(mfloat_t p);
4292 mfloat_t bounce_ease_in_out(mfloat_t p);
4293 #endif
4294
4295 #endif
4296