PeriDyno 1.0.0
Loading...
Searching...
No Matches
vgMath.h
Go to the documentation of this file.
1//------------------------------------------------------------------------------
2// Copyright (c) 2018-2020 Michele Morrone
3// All rights reserved.
4//
5// https://michelemorrone.eu - https://BrutPitt.com
6//
7// twitter: https://twitter.com/BrutPitt - github: https://github.com/BrutPitt
8//
9// mailto:brutpitt@gmail.com - mailto:me@michelemorrone.eu
10//
11// This software is distributed under the terms of the BSD 2-Clause license
12//------------------------------------------------------------------------------
13#pragma once
14
15#include "vgConfig.h"
16
17#ifdef VGM_USES_DOUBLE_PRECISION
18 #define VG_T_TYPE double
19 #define VGM_USES_TEMPLATE
20#else
21 #define VG_T_TYPE float
22#endif
23
24#ifdef VGIZMO_USES_GLM
25 #ifndef VGM_USES_TEMPLATE
26 #define VGM_USES_TEMPLATE // glm uses template ==> vGizmo needs to know
27 #endif
28
29 #define VGM_NAMESPACE glm
30
31 #include <glm/glm.hpp>
32 #include <glm/gtx/vector_angle.hpp>
33 #include <glm/gtx/exterior_product.hpp>
34 #include <glm/gtc/type_ptr.hpp>
35 #include <glm/gtc/quaternion.hpp>
36 #include <glm/gtc/matrix_transform.hpp>
37
38 using tVec2 = glm::tvec2<VG_T_TYPE>;
39 using tVec3 = glm::tvec3<VG_T_TYPE>;
40 using tVec4 = glm::tvec4<VG_T_TYPE>;
41 using tQuat = glm::tquat<VG_T_TYPE>;
42 using tMat3 = glm::tmat3x3<VG_T_TYPE>;
43 using tMat4 = glm::tmat4x4<VG_T_TYPE>;
44
45 #define T_PI glm::pi<VG_T_TYPE>()
46 #define T_INV_PI glm::one_over_pi<VG_T_TYPE>()
47
48 #define VGIZMO_BASE_CLASS virtualGizmoBaseClass<T>
49 #define TEMPLATE_TYPENAME_T template<typename T>
50
51#else // use vGizmoMath
52
53 #include <math.h>
54 #include <cmath>
55 #include <stdint.h>
56 #define VGM_NAMESPACE vgm
57
58 #ifdef VGM_USES_TEMPLATE
59 #define TEMPLATE_TYPENAME_T template<typename T>
60
61 #define VEC2_T Vec2<T>
62 #define VEC3_T Vec3<T>
63 #define VEC4_T Vec4<T>
64 #define QUAT_T Quat<T>
65 #define MAT3_T Mat3<T>
66 #define MAT4_T Mat4<T>
67
68 #define VEC2_PRECISION Vec2<VG_T_TYPE>
69 #define VEC3_PRECISION Vec3<VG_T_TYPE>
70 #define VEC4_PRECISION Vec4<VG_T_TYPE>
71 #define QUAT_PRECISION Quat<VG_T_TYPE>
72 #define MAT3_PRECISION Mat3<VG_T_TYPE>
73 #define MAT4_PRECISION Mat4<VG_T_TYPE>
74
75 #define T_PI vgm::pi<VG_T_TYPE>()
76 #define T_INV_PI vgm::one_over_pi<VG_T_TYPE>()
77
78 #else
79 #define TEMPLATE_TYPENAME_T
80
81 #define VEC2_T Vec2
82 #define VEC3_T Vec3
83 #define VEC4_T Vec4
84 #define QUAT_T Quat
85 #define MAT3_T Mat3
86 #define MAT4_T Mat4
87
88 #define VEC2_PRECISION Vec2
89 #define VEC3_PRECISION Vec3
90 #define VEC4_PRECISION Vec4
91 #define QUAT_PRECISION Quat
92 #define MAT3_PRECISION Mat3
93 #define MAT4_PRECISION Mat4
94
95 #define T_PI vgm::pi()
96 #define T_INV_PI vgm::one_over_pi()
97 #endif
98
99namespace vgm {
100
103
104#if !defined(VGM_USES_TEMPLATE)
105 #define T VG_T_TYPE
106#endif
107
108// Vec2
111public:
112 union {
113 struct { T x, y; };
114 struct { T u, v; };
115 };
116
117 Vec2() = default;
118 Vec2(const VEC2_T&) = default;
119 explicit Vec2(T s) : x(s), y(s) {}
120 Vec2(T x, T y) : x(x), y(y) {}
121
122 Vec2 operator-() const { return {-x, -y}; }
123
124 Vec2& operator+=(const Vec2& v) { x += v.x; y += v.y; return *this; }
125 Vec2& operator-=(const Vec2& v) { x -= v.x; y -= v.y; return *this; }
126 Vec2& operator*=(const Vec2& v) { x *= v.x; y *= v.y; return *this; }
127 Vec2& operator/=(const Vec2& v) { x /= v.x; y /= v.y; return *this; }
128 Vec2& operator*=(T s) { x *= s ; y *= s ; return *this; }
129 Vec2& operator/=(T s) { x /= s ; y /= s ; return *this; }
130
131 Vec2 operator+(const Vec2& v) const { return { x + v.x, y + v.y }; }
132 Vec2 operator-(const Vec2& v) const { return { x - v.x, y - v.y }; }
133 Vec2 operator*(const Vec2& v) const { return { x * v.x, y * v.y }; }
134 Vec2 operator/(const Vec2& v) const { return { x / v.x, y / v.y }; }
135 Vec2 operator*(T s) const { return { x * s , y * s }; }
136 Vec2 operator/(T s) const { return { x / s , y / s }; }
137
138 const T& operator[](int i) const { return *(&x + i); }
139 T& operator[](int i) { return *(&x + i); }
140
141 explicit operator const T *() const { return &x; }
142 explicit operator T *() { return &x; }
143};
144// Vec3
147public:
148 union {
149 struct { T x, y, z; };
150 struct { T r, g, b; };
151 };
152
153 Vec3() = default;
154 Vec3(const VEC3_T&) = default;
155 explicit Vec3(T s) : x(s), y(s), z(s) {}
156 Vec3(T x, T y, T z) : x(x), y(y), z(z) {}
157 explicit Vec3(T s, const VEC2_T& v) : x(s), y(v.x), z(v.y) {}
158 explicit Vec3(const VEC2_T& v, T s) : x(v.x), y(v.y), z(s) {}
159 Vec3(const VEC4_T& v);
160
161 Vec3 operator-() const { return {-x, -y, -z}; }
162
163 Vec3& operator+=(const Vec3& v) { x += v.x; y += v.y; z += v.z; return *this; }
164 Vec3& operator-=(const Vec3& v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
165 Vec3& operator*=(const Vec3& v) { x *= v.x; y *= v.y; z *= v.z; return *this; }
166 Vec3& operator/=(const Vec3& v) { x /= v.x; y /= v.y; z /= v.z; return *this; }
167 Vec3& operator*=(T s) { x *= s ; y *= s ; z *= s ; return *this; }
168 Vec3& operator/=(T s) { x /= s ; y /= s ; z /= s ; return *this; }
169
170 Vec3 operator+(const Vec3& v) const { return { x + v.x, y + v.y, z + v.z }; }
171 Vec3 operator-(const Vec3& v) const { return { x - v.x, y - v.y, z - v.z }; }
172 Vec3 operator*(const Vec3& v) const { return { x * v.x, y * v.y, z * v.z }; }
173 Vec3 operator/(const Vec3& v) const { return { x / v.x, y / v.y, z / v.z }; }
174 Vec3 operator*(T s) const { return { x * s , y * s , z * s }; }
175 Vec3 operator/(T s) const { return { x / s , y / s , z / s }; }
176
177 const T& operator[](int i) const { return *(&x + i); }
178 T& operator[](int i) { return *(&x + i); }
179
180 explicit operator const T *() const { return &x; }
181 explicit operator T *() { return &x; }
182};
183// Vec4
186public:
187 union {
188 struct { T x, y, z, w; };
189 struct { T r, g, b, a; };
190 };
191
192 Vec4() = default;
193 Vec4(const VEC4_T&) = default;
194 explicit Vec4(T s) : x(s), y(s), z(s), w(s) {}
195 Vec4(T x, T y, T z, T w) : x(x), y(y), z(z), w(w) {}
196 explicit Vec4(const VEC3_T& v, T s) : x(v.x), y(v.y), z(v.z), w(s) {}
197 explicit Vec4(T s, const VEC3_T& v) : x(s), y(v.x), z(v.y), w(v.z) {}
198
199 //operator VEC3_T() const { return *((VEC3_T *) &x); }
200 Vec4 operator-() const { return {-x, -y, -z, -w}; }
201
202 Vec4& operator+=(const Vec4& v) { x += v.x; y += v.y; z += v.z; w += v.w; return *this; }
203 Vec4& operator-=(const Vec4& v) { x -= v.x; y -= v.y; z -= v.z; w -= v.w; return *this; }
204 Vec4& operator*=(const Vec4& v) { x *= v.x; y *= v.y; z *= v.z; w *= v.w; return *this; }
205 Vec4& operator/=(const Vec4& v) { x /= v.x; y /= v.y; z /= v.z; w /= v.w; return *this; }
206 Vec4& operator*=(T s) { x *= s ; y *= s ; z *= s ; w *= s ; return *this; }
207 Vec4& operator/=(T s) { x /= s ; y /= s ; z /= s ; w /= s ; return *this; }
208
209 Vec4 operator+(const Vec4& v) const { return { x + v.x, y + v.y, z + v.z, w + v.w }; }
210 Vec4 operator-(const Vec4& v) const { return { x - v.x, y - v.y, z - v.z, w - v.w }; }
211 Vec4 operator*(const Vec4& v) const { return { x * v.x, y * v.y, z * v.z, w * v.w }; }
212 Vec4 operator/(const Vec4& v) const { return { x / v.x, y / v.y, z / v.z, w / v.w }; }
213 Vec4 operator*(T s) const { return { x * s , y * s , z * s , w * s }; }
214 Vec4 operator/(T s) const { return { x / s , y / s , z / s , w / s }; }
215
216 const T& operator[](int i) const { return *(&x + i); }
217 T& operator[](int i) { return *(&x + i); }
218
219 explicit operator const T *() const { return &x; }
220 explicit operator T *() { return &x; }
221};
222// Quat
225public:
226 T x, y, z, w;
227
228 Quat() = default;
229 Quat(const QUAT_T&) = default;
230 Quat(T w, T x, T y, T z) : x(x), y(y), z(z), w(w) {}
231 explicit Quat(T s, const VEC3_T& v) : x(v.x), y(v.y), z(v.z), w(s) {}
232
233 Quat operator-() const { return Quat(-w, -x, -y, -z); }
234
235 Quat& operator+=(const Quat& q) { x += q.x; y += q.y; z += q.z; w += q.w; return *this; }
236 Quat& operator-=(const Quat& q) { x -= q.x; y -= q.y; z -= q.z; w -= q.w; return *this; }
237 Quat& operator*=(const Quat& q) { return *this = *this * q; }
238 Quat& operator*=(T s) { x *= s ; y *= s ; z *= s ; w *= s ; return *this; }
239 Quat& operator/=(T s) { x /= s ; y /= s ; z /= s ; w /= s ; return *this; }
240
241 Quat operator+(const Quat& q) const { return { w + q.w, x + q.x, y + q.y, z + q.z }; }
242 Quat operator-(const Quat& q) const { return { w - q.w, x - q.x, y - q.y, z - q.z }; }
243 Quat operator*(const Quat& q) const { return { w * q.w - x * q.x - y * q.y - z * q.z,
244 w * q.x + x * q.w + y * q.z - z * q.y,
245 w * q.y + y * q.w + z * q.x - x * q.z,
246 w * q.z + z * q.w + x * q.y - y * q.x }; }
247
248 Quat operator*(T s) const { return { w * s, x * s , y * s , z * s }; }
249 Quat operator/(T s) const { return { w / s, x / s , y / s , z / s }; }
250
251 const T& operator[](int i) const { return *(&x + i); }
252 T& operator[](int i) { return *(&x + i); }
253
254 explicit operator const T *() const { return &x; }
255 explicit operator T *() { return &x; }
256};
257// Mat3
260public:
261 union {
263 struct { T m00, m01, m02,
265 m20, m21, m22; };
266 };
267
268 Mat3() = default;
269 Mat3(const MAT3_T &) = default;
270 explicit Mat3(T s) : v { VEC3_T(s, 0, 0), VEC3_T(0, s, 0), VEC3_T(0, 0, s) } {}
271 Mat3(const VEC3_T& v0, const VEC3_T& v1, const VEC3_T& v2) : v {v0, v1, v2 } {}
272 Mat3(const MAT4_T& m);
273 Mat3(T v0x, T v0y, T v0z,
274 T v1x, T v1y, T v1z,
275 T v2x, T v2y, T v2z) : v { VEC3_T(v0x, v0y, v0z), VEC3_T(v1x, v1y, v1z), VEC3_T(v2x, v2y, v2z) } {}
276
277 const VEC3_T& operator[](int i) const { return v[i]; }
278 VEC3_T& operator[](int i) { return v[i]; }
279
280 Mat3 operator-() const { return Mat3(-v[0], -v[1], -v[2]); }
281
282 Mat3& operator+=(const Mat3& m) { v[0] += m.v[0]; v[1] += m.v[1]; v[2] += m.v[2]; return *this; }
283 Mat3& operator-=(const Mat3& m) { v[0] -= m.v[0]; v[1] -= m.v[1]; v[2] -= m.v[2]; return *this; }
284 Mat3& operator/=(const Mat3& m) { v[0] /= m.v[0]; v[1] /= m.v[1]; v[2] /= m.v[2]; return *this; }
285 Mat3& operator*=(T s) { v[0] *= s; v[1] *= s; v[2] *= s; return *this; }
286 Mat3& operator/=(T s) { v[0] /= s; v[1] /= s; v[2] /= s; return *this; }
287 Mat3& operator*=(const Mat3& m) { return *this = *this * m; }
288
289 Mat3 operator+(const Mat3& m) const { return { v[0] + m.v[0], v[1] + m.v[1], v[2] + m.v[2] }; }
290 Mat3 operator-(const Mat3& m) const { return { v[0] - m.v[0], v[1] - m.v[1], v[2] - m.v[2] }; }
291#define M(X,Y) (m##X * m.m##Y)
292 Mat3 operator*(const Mat3& m) const { return { M(00,00) + M(10,01) + M(20,02),
293 M(01,00) + M(11,01) + M(21,02),
294 M(02,00) + M(12,01) + M(22,02),
295 M(00,10) + M(10,11) + M(20,12),
296 M(01,10) + M(11,11) + M(21,12),
297 M(02,10) + M(12,11) + M(22,12),
298 M(00,20) + M(10,21) + M(20,22),
299 M(01,20) + M(11,21) + M(21,22),
300 M(02,20) + M(12,21) + M(22,22)}; }
301#undef M
302 Mat3 operator*(T s) const { return { v[0] * s, v[1] * s, v[2] * s }; }
303 Mat3 operator/(T s) const { return { v[0] / s, v[1] / s, v[2] / s }; }
304
305 VEC3_T operator*(const VEC3_T& v) const { return { m00 * v.x + m10 * v.y + m20 * v.z,
306 m01 * v.x + m11 * v.y + m21 * v.z,
307 m02 * v.x + m12 * v.y + m22 * v.z }; }
308 explicit operator const T *() const { return &m00; }
309 explicit operator T *() { return &m00; }
310};
311// Mat4
314public:
315 union {
317 struct { T m00, m01, m02, m03,
320 m30, m31, m32, m33; };
321 };
322
323 Mat4() = default;
324 explicit Mat4(T s) : v { VEC4_T(s, 0, 0, 0), VEC4_T(0, s, 0, 0), VEC4_T(0, 0, s, 0), VEC4_T(0, 0, 0, s)} {}
325 Mat4(const VEC4_T& v0, const VEC4_T& v1, const VEC4_T& v2, const VEC4_T& v3) : v {v0, v1, v2, v3} {}
326 Mat4(const MAT3_T& m) : v {VEC4_T(m.v[0],0), VEC4_T(m.v[1],0), VEC4_T(m.v[2],0), VEC4_T(0, 0, 0, 1)} {}
327 Mat4(T v0x, T v0y, T v0z, T v0w,
328 T v1x, T v1y, T v1z, T v1w,
329 T v2x, T v2y, T v2z, T v2w,
330 T v3x, T v3y, T v3z, T v3w) : v {VEC4_T(v0x, v0y, v0z, v0w), VEC4_T(v1x, v1y, v1z, v1w), VEC4_T(v2x, v2y, v2z, v2w), VEC4_T(v3x, v3y, v3z, v3w) } {}
331
332 const VEC4_T& operator[](int i) const { return v[i]; }
333 VEC4_T& operator[](int i) { return v[i]; }
334
335 Mat4 operator-() const { return { -v[0], -v[1], -v[2], -v[3] }; }
336
337 Mat4& operator+=(const Mat4& m) { v[0] += m.v[0]; v[1] += m.v[1]; v[2] += m.v[2]; v[3] += m.v[3]; return *this; }
338 Mat4& operator-=(const Mat4& m) { v[0] -= m.v[0]; v[1] -= m.v[1]; v[2] -= m.v[2]; v[3] -= m.v[3]; return *this; }
339 Mat4& operator/=(const Mat4& m) { v[0] /= m.v[0]; v[1] /= m.v[1]; v[2] /= m.v[2]; v[3] /= m.v[3]; return *this; }
340 Mat4& operator*=(T s) { v[0] *= s; v[1] *= s; v[2] *= s; v[3] *= s; return *this; }
341 Mat4& operator/=(T s) { v[0] /= s; v[1] /= s; v[2] /= s; v[3] /= s; return *this; }
342 Mat4& operator*=(const Mat4& m) { return *this = *this * m; }
343
344 Mat4 operator+(const Mat4& m) const { return { v[0] + m.v[0], v[1] + m.v[1], v[2] + m.v[2], v[3] + m.v[3] }; }
345 Mat4 operator-(const Mat4& m) const { return { v[0] - m.v[0], v[1] - m.v[1], v[2] - m.v[2], v[3] - m.v[3] }; }
346 Mat4 operator*(T s) const { return { v[0] * s , v[1] * s , v[2] * s , v[3] * s }; }
347 Mat4 operator/(T s) const { return { v[0] / s , v[1] / s , v[2] / s , v[3] / s }; }
348#define M(X,Y) (m##X * m.m##Y)
349 Mat4 operator*(const Mat4& m) const { return { M(00,00) + M(10,01) + M(20,02) + M(30,03),
350 M(01,00) + M(11,01) + M(21,02) + M(31,03),
351 M(02,00) + M(12,01) + M(22,02) + M(32,03),
352 M(03,00) + M(13,01) + M(23,02) + M(33,03),
353 M(00,10) + M(10,11) + M(20,12) + M(30,13),
354 M(01,10) + M(11,11) + M(21,12) + M(31,13),
355 M(02,10) + M(12,11) + M(22,12) + M(32,13),
356 M(03,10) + M(13,11) + M(23,12) + M(33,13),
357 M(00,20) + M(10,21) + M(20,22) + M(30,23),
358 M(01,20) + M(11,21) + M(21,22) + M(31,23),
359 M(02,20) + M(12,21) + M(22,22) + M(32,23),
360 M(03,20) + M(13,21) + M(23,22) + M(33,23),
361 M(00,30) + M(10,31) + M(20,32) + M(30,33),
362 M(01,30) + M(11,31) + M(21,32) + M(31,33),
363 M(02,30) + M(12,31) + M(22,32) + M(32,33),
364 M(03,30) + M(13,31) + M(23,32) + M(33,33) }; }
365#undef M
366 VEC4_T operator*(const VEC4_T& v) const { return { m00 * v.x + m10 * v.y + m20 * v.z + m30 * v.w,
367 m01 * v.x + m11 * v.y + m21 * v.z + m31 * v.w,
368 m02 * v.x + m12 * v.y + m22 * v.z + m32 * v.w,
369 m03 * v.x + m13 * v.y + m23 * v.z + m33 * v.w }; }
370 explicit operator const T *() const { return &m00; }
371 explicit operator T *() { return &m00; }
372};
373// cast / conversion
375TEMPLATE_TYPENAME_T inline VEC3_T::Vec3(const VEC4_T& v) : VEC3_T{ v.x, v.y, v.z } {}
376TEMPLATE_TYPENAME_T inline MAT3_T::Mat3(const MAT4_T& m) : v { VEC3_T(m.v[0]), m.v[1], m.v[2] } {}
378 T xx(q.x * q.x); T yy(q.y * q.y); T zz(q.z * q.z);
379 T xz(q.x * q.z); T xy(q.x * q.y); T yz(q.y * q.z);
380 T wx(q.w * q.x); T wy(q.w * q.y); T wz(q.w * q.z);
381
382 return { T(1) - T(2) * (yy + zz), T(2) * (xy + wz), T(2) * (xz - wy),
383 T(2) * (xy - wz), T(1) - T(2) * (xx + zz), T(2) * (yz + wx),
384 T(2) * (xz + wy), T(2) * (yz - wx), T(1) - T(2) * (xx + yy) }; }
385TEMPLATE_TYPENAME_T inline MAT4_T mat4_cast(QUAT_T const& q) { return { mat3_cast(q) }; }
386inline float uintBitsToFloat(uint32_t const v) { return *((float *)(&v)); }
387inline uint32_t floatBitsToUint(float const v) { return *((uint32_t *)(&v)); }
388// dot
390TEMPLATE_TYPENAME_T inline T dot(const VEC2_T& v0, const VEC2_T& v1) { return v0.x * v1.x + v0.y * v1.y; }
391TEMPLATE_TYPENAME_T inline T dot(const VEC3_T& v0, const VEC3_T& v1) { return v0.x * v1.x + v0.y * v1.y + v0.z * v1.z; }
392TEMPLATE_TYPENAME_T inline T dot(const VEC4_T& v0, const VEC4_T& v1) { return v0.x * v1.x + v0.y * v1.y + v0.z * v1.z + v0.w * v1.w; }
393TEMPLATE_TYPENAME_T inline T dot(const QUAT_T& q0, const QUAT_T& q1) { return q0.x * q1.x + q0.y * q1.y + q0.z * q1.z + q0.w * q1.w; }
394// cross
396TEMPLATE_TYPENAME_T inline T cross(const VEC2_T& u, const VEC2_T& v) { return u.x * v.y - v.x * u.y; }
397TEMPLATE_TYPENAME_T inline VEC3_T cross(const VEC3_T& u, const VEC3_T& v) { return { u.y * v.z - u.z * v.y, u.z * v.x - u.x * v.z, u.x * v.y - u.y * v.x }; }
398// length
400TEMPLATE_TYPENAME_T inline T length(const VEC2_T& v) { return sqrt(dot(v, v)); }
401TEMPLATE_TYPENAME_T inline T length(const VEC3_T& v) { return sqrt(dot(v, v)); }
402TEMPLATE_TYPENAME_T inline T length(const VEC4_T& v) { return sqrt(dot(v, v)); }
403TEMPLATE_TYPENAME_T inline T length(const QUAT_T& q) { return sqrt(dot(q, q)); }
404// distance
406TEMPLATE_TYPENAME_T inline T distance(const VEC2_T& v0, const VEC2_T& v1) { return length(v1 - v0); }
407TEMPLATE_TYPENAME_T inline T distance(const VEC3_T& v0, const VEC3_T& v1) { return length(v1 - v0); }
408TEMPLATE_TYPENAME_T inline T distance(const VEC4_T& v0, const VEC4_T& v1) { return length(v1 - v0); }
409// abs
411TEMPLATE_TYPENAME_T inline T tAbs(T x) { return x>=T(0) ? x : -x; }
412TEMPLATE_TYPENAME_T inline VEC2_T abs(const VEC2_T& v) { return { tAbs(v.x), tAbs(v.y) }; }
413TEMPLATE_TYPENAME_T inline VEC3_T abs(const VEC3_T& v) { return { tAbs(v.x), tAbs(v.y), tAbs(v.z) }; }
414TEMPLATE_TYPENAME_T inline VEC4_T abs(const VEC4_T& v) { return { tAbs(v.x), tAbs(v.y), tAbs(v.z), tAbs(v.w) }; }
415TEMPLATE_TYPENAME_T inline QUAT_T abs(const QUAT_T& q) { return { tAbs(q.w), tAbs(q.x), tAbs(q.y), tAbs(q.z) }; }
416// sign
418TEMPLATE_TYPENAME_T inline T sign(const T v) { return v>T(0) ? T(1) : ( v<T(0) ? T(-1) : T(0)); }
419// normalize
421TEMPLATE_TYPENAME_T inline VEC2_T normalize(const VEC2_T& v) { return v / length(v); }
422TEMPLATE_TYPENAME_T inline VEC3_T normalize(const VEC3_T& v) { return v / length(v); }
423TEMPLATE_TYPENAME_T inline VEC4_T normalize(const VEC4_T& v) { return v / length(v); }
424TEMPLATE_TYPENAME_T inline QUAT_T normalize(const QUAT_T& q) { return q / length(q); }
425// mix
427TEMPLATE_TYPENAME_T inline T mix(const T x, const T y, const T a) { return x + (y-x) * a; }
428TEMPLATE_TYPENAME_T inline VEC2_T mix(const VEC2_T& x, const VEC2_T& y, const T a) { return x + (y-x) * a; }
429TEMPLATE_TYPENAME_T inline VEC3_T mix(const VEC3_T& x, const VEC3_T& y, const T a) { return x + (y-x) * a; }
430TEMPLATE_TYPENAME_T inline VEC4_T mix(const VEC4_T& x, const VEC4_T& y, const T a) { return x + (y-x) * a; }
431// pow
433TEMPLATE_TYPENAME_T inline VEC2_T pow(const VEC2_T& b, const VEC2_T& e) { return { ::pow(b.x,e.x), ::pow(b.y,e.y) }; }
434TEMPLATE_TYPENAME_T inline VEC3_T pow(const VEC3_T& b, const VEC3_T& e) { return { ::pow(b.x,e.x), ::pow(b.y,e.y), ::pow(b.z,e.z) }; }
435TEMPLATE_TYPENAME_T inline VEC4_T pow(const VEC4_T& b, const VEC4_T& e) { return { ::pow(b.x,e.x), ::pow(b.y,e.y), ::pow(b.z,e.z), ::pow(b.w,e.w) }; }
436// value_ptr
438TEMPLATE_TYPENAME_T inline T *value_ptr(const VEC2_T &v) { return const_cast<T *>(&v.x); }
439TEMPLATE_TYPENAME_T inline T *value_ptr(const VEC3_T &v) { return const_cast<T *>(&v.x); }
440TEMPLATE_TYPENAME_T inline T *value_ptr(const VEC4_T &v) { return const_cast<T *>(&v.x); }
441TEMPLATE_TYPENAME_T inline T *value_ptr(const QUAT_T &q) { return const_cast<T *>(&q.x); }
442TEMPLATE_TYPENAME_T inline T *value_ptr(const MAT3_T &m) { return const_cast<T *>(&m.m00); }
443TEMPLATE_TYPENAME_T inline T *value_ptr(const MAT4_T &m) { return const_cast<T *>(&m.m00); }
444// transpose
447 return { m.m00, m.m10, m.m20,
448 m.m01, m.m11, m.m21,
449 m.m02, m.m12, m.m22}; }
451 return { m.m00, m.m10, m.m20, m.m30,
452 m.m01, m.m11, m.m21, m.m31,
453 m.m02, m.m12, m.m22, m.m32,
454 m.m03, m.m13, m.m23, m.m33}; }
455// inverse
457#define M(X,Y) (m.m##X * m.m##Y)
458TEMPLATE_TYPENAME_T inline QUAT_T inverse(QUAT_T const &q) { return QUAT_T(q.w, -q.x, -q.y, -q.z) / dot(q, q); }
460 T invDet = T(1) / (m.m00 * (M(11,22) - M(21,12)) - m.m10 * (M(01,22) - M(21,02)) + m.m20 * (M(01,12) - M(11,02)));
461 return MAT3_T( (M(11,22) - M(21,12)), - (M(01,22) - M(21,02)), (M(01,12) - M(11,02)),
462 - (M(10,22) - M(20,12)), (M(00,22) - M(20,02)), - (M(00,12) - M(10,02)),
463 (M(10,21) - M(20,11)), - (M(00,21) - M(20,01)), (M(00,11) - M(10,01))) * invDet; } // ==> "operator *" is faster
465 const T c0 = M(22,33) - M(32,23); VEC4_T f0(c0, c0, M(12,33) - M(32,13), M(12,23) - M(22,13));
466 const T c1 = M(21,33) - M(31,23); VEC4_T f1(c1, c1, M(11,33) - M(31,13), M(11,23) - M(21,13));
467 const T c2 = M(21,32) - M(31,22); VEC4_T f2(c2, c2, M(11,32) - M(31,12), M(11,22) - M(21,12));
468 const T c3 = M(20,33) - M(30,23); VEC4_T f3(c3, c3, M(10,33) - M(30,13), M(10,23) - M(20,13));
469 const T c4 = M(20,32) - M(30,22); VEC4_T f4(c4, c4, M(10,32) - M(30,12), M(10,22) - M(20,12));
470 const T c5 = M(20,31) - M(30,21); VEC4_T f5(c5, c5, M(10,31) - M(30,11), M(10,21) - M(20,11));
471#undef M
472 VEC4_T v0(m.m10, m.m00, m.m00, m.m00);
473 VEC4_T v1(m.m11, m.m01, m.m01, m.m01);
474 VEC4_T v2(m.m12, m.m02, m.m02, m.m02);
475 VEC4_T v3(m.m13, m.m03, m.m03, m.m03);
476
477 VEC4_T signV(T(1), T(-1), T(1), T(-1));
478 MAT4_T inv((v1 * f0 - v2 * f1 + v3 * f2) * signV,
479 (v0 * f0 - v2 * f3 + v3 * f4) * -signV,
480 (v0 * f1 - v1 * f3 + v3 * f5) * signV,
481 (v0 * f2 - v1 * f4 + v2 * f5) * -signV);
482
483 VEC4_T v0r0(m.v[0] * VEC4_T(inv.m00, inv.m10, inv.m20, inv.m30));
484 return inv * (T(1) / (v0r0.x + v0r0.y + v0r0.z + v0r0.w)); }// 1/determinant ==> "operator *" is faster
485// external operators
487TEMPLATE_TYPENAME_T inline VEC2_T operator*(const T s, const VEC2_T& v) { return v * s; }
488TEMPLATE_TYPENAME_T inline VEC3_T operator*(const T s, const VEC3_T& v) { return v * s; }
489TEMPLATE_TYPENAME_T inline VEC4_T operator*(const T s, const VEC4_T& v) { return v * s; }
490TEMPLATE_TYPENAME_T inline QUAT_T operator*(const T s, const QUAT_T& q) { return q * s; }
491
492TEMPLATE_TYPENAME_T inline VEC2_T operator/(const T s, const VEC2_T& v) { return { s/v.x, s/v.y }; }
493TEMPLATE_TYPENAME_T inline VEC3_T operator/(const T s, const VEC3_T& v) { return { s/v.x, s/v.y, s/v.z }; }
494TEMPLATE_TYPENAME_T inline VEC4_T operator/(const T s, const VEC4_T& v) { return { s/v.x, s/v.y, s/v.z, s/v.w }; }
495TEMPLATE_TYPENAME_T inline QUAT_T operator/(const T s, const QUAT_T& q) { return { s/q.x, s/q.y, s/q.z, s/q.w }; }
496
498 const VEC3_T qV(q.x, q.y, q.z), uv(cross(qV, v));
499 return v + ((uv * q.w) + cross(qV, uv)) * T(2); }
500TEMPLATE_TYPENAME_T inline VEC3_T operator*(const VEC3_T& v, const QUAT_T& q) { return inverse(q) * v; }
501// translate / scale
504 MAT4_T r(m); r[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
505 return r; }
506TEMPLATE_TYPENAME_T inline MAT4_T scale(MAT4_T const& m, VEC3_T const& v) {
507 return MAT4_T(m[0] * v[0], m[1] * v[1], m[2] * v[2], m[3]); }
508// quat angle/axis
510TEMPLATE_TYPENAME_T inline QUAT_T angleAxis(T const &a, VEC3_T const &v) { return QUAT_T(cos(a * T(0.5)), v * sin(a * T(0.5))); }
511TEMPLATE_TYPENAME_T inline T angle(QUAT_T const& q) { return acos(q.w) * T(2); }
513 const T t1 = T(1) - q.w * q.w; if(t1 <= T(0)) return VEC3_T(0, 0, 1);
514 const T t2 = T(1) / sqrt(t1); return VEC3_T(q.x * t2, q.y * t2, q.z * t2); }
515// trigonometric
517TEMPLATE_TYPENAME_T inline T radians(T d) { return d * T(0.0174532925199432957692369076849); }
518TEMPLATE_TYPENAME_T inline T degrees(T r) { return r * T(57.295779513082320876798154814105); }
519TEMPLATE_TYPENAME_T inline T pi() { return T(3.1415926535897932384626433832795029); }
520TEMPLATE_TYPENAME_T inline T one_over_pi() { return T(0.318309886183790671537767526745028724); }
521
522// lookAt
524TEMPLATE_TYPENAME_T inline MAT4_T lookAt(const VEC3_T& pov, const VEC3_T& tgt, const VEC3_T& up)
525{
526#ifdef VGM_USES_LEFT_HAND_AXES
527 VEC3_T k = normalize(tgt - pov), i = normalize(cross(up, k)), j = cross(k, i);
528#else
529 VEC3_T k = normalize(tgt - pov), i = normalize(cross(k, up)), j = cross(i, k); k = -k;
530#endif
531 return { i.x, j.x, k.x, T(0),
532 i.y, j.y, k.y, T(0),
533 i.z, j.z, k.z, T(0),
534 -dot(i, pov), -dot(j, pov), -dot(k, pov), T(1)}; }
535// ortho
537TEMPLATE_TYPENAME_T inline MAT4_T ortho(T l, T r, T b, T t, T n, T f)
538{
539#ifdef VGM_USES_LEFT_HAND_AXES
540 const T v = T(2);
541#else
542 const T v = T(-2);
543#endif
544 return { T(2)/(r-l), T(0), T(0), T(0),
545 T(0), T(2)/(t-b), T(0), T(0),
546 T(0), T(0), v/(f-n), T(0),
547 -(r+l)/(r-l), -(t+b)/(t-b), -(f+n)/(f-n), T(1)}; }
548// perspective
551{
552#ifdef VGM_USES_LEFT_HAND_AXES
553 const T v = T(1), f_n = (f+n)/(f-n);
554#else
555 const T v = T(-1), f_n = -(f+n)/(f-n);
556#endif
557 const T hFovy = tan(fovy / T(2));
558 return { T(1)/(a*hFovy), T(0), T(0), T(0),
559 T(0), T(1)/(hFovy), T(0), T(0),
560 T(0), T(0), f_n, v ,
561 T(0), T(0), -(T(2)*f*n)/(f-n), T(0)}; }
562// perspectiveFov
564TEMPLATE_TYPENAME_T inline MAT4_T perspectiveFov(T fovy, T w, T h, T n, T f) { return perspective(fovy, w/h, n, f); }
565// frustrum
567TEMPLATE_TYPENAME_T inline MAT4_T frustum(T l, T r, T b, T t, T n, T f)
568{
569#ifdef VGM_USES_LEFT_HAND_AXES
570 const T v = T(1), f_n = (f+n)/(f-n);
571#else
572 const T v = T(-1), f_n = -(f+n)/(f-n);
573#endif
574 return { (T(2)*n)/(r-l), T(0), T(0), T(0),
575 T(0), (T(2)*n)/(t-b), T(0), T(0),
576 (r+l)/(r-l), (t+b)/(t-b), f_n, v ,
577 T(0), T(0), -(T(2)*f*n)/(f-n), T(0)}; }
578
579} // end namespace vgm
580
581#ifdef VGM_USES_TEMPLATE
582 using vec2 = vgm::Vec2<float>;
583 using vec3 = vgm::Vec3<float>;
584 using vec4 = vgm::Vec4<float>;
585 using quat = vgm::Quat<float>;
586 using mat3 = vgm::Mat3<float>;
587 using mat4 = vgm::Mat4<float>;
588 using mat3x3 = mat3;
589 using mat4x4 = mat4;
590
591 using dvec2 = vgm::Vec2<double>;
592 using dvec3 = vgm::Vec3<double>;
593 using dvec4 = vgm::Vec4<double>;
594 using dquat = vgm::Quat<double>;
595 using dmat3 = vgm::Mat3<double>;
596 using dmat4 = vgm::Mat4<double>;
597 using dmat3x3 = dmat3;
598 using dmat4x4 = dmat4;
599
600 using ivec2 = vgm::Vec2<int32_t>;
601 using ivec3 = vgm::Vec3<int32_t>;
602 using ivec4 = vgm::Vec4<int32_t>;
603
604 using uvec2 = vgm::Vec2<uint32_t>;
605 using uvec3 = vgm::Vec3<uint32_t>;
606 using uvec4 = vgm::Vec4<uint32_t>;
607
608#ifdef VGIZMO_USES_HLSL_TYPES // testing phase
609 using float2 = vgm::Vec2<float>;
610 using float3 = vgm::Vec3<float>;
611 using float4 = vgm::Vec4<float>;
612 using float3x3 = vgm::Mat3<float>;
613 using float4x4 = vgm::Mat4<float>;
614
615 using double2 = vgm::Vec2<double>;
616 using double3 = vgm::Vec3<double>;
617 using double4 = vgm::Vec4<double>;
618 using double3x3 = vgm::Mat3<double>;
619 using double4x4 = vgm::Mat4<double>;
620
621 using int2 = vgm::Vec2<int32_t>;
622 using int3 = vgm::Vec3<int32_t>;
623 using int4 = vgm::Vec4<int32_t>;
624
625 using uint2 = vgm::Vec2<uint32_t>;
626 using uint3 = vgm::Vec3<uint32_t>;
627 using uint4 = vgm::Vec4<uint32_t>;
628#endif
629#else
636 using mat3x3 = mat3;
637 using mat4x4 = mat4;
638
639#ifdef VGIZMO_USES_HLSL_TYPES
640 using float2 = vgm::Vec2;
641 using float3 = vgm::Vec3;
642 using float4 = vgm::Vec4;
643 using float3x3 = vgm::Mat3;
644 using float4x4 = vgm::Mat4;
645#endif
646
647#endif
648// Internal vGizmo USES ONLY
649 using tVec2 = vgm::VEC2_PRECISION;
650 using tVec3 = vgm::VEC3_PRECISION;
651 using tVec4 = vgm::VEC4_PRECISION;
652 using tQuat = vgm::QUAT_PRECISION;
653 using tMat3 = vgm::MAT3_PRECISION;
654 using tMat4 = vgm::MAT4_PRECISION;
655
656 using uint8 = uint8_t;
657 using int8 = int8_t;
658 using uint = uint32_t;
659 using int32 = int32_t;
660 using uint32 = uint32_t;
661 using int64 = int64_t;
662 using uint64 = uint64_t;
663
664 #undef VEC2_T
665 #undef VEC3_T
666 #undef VEC4_T
667 #undef QUAT_T
668 #undef MAT3_T
669 #undef MAT4_T
670
671 #undef VEC2_PRECISION
672 #undef VEC3_PRECISION
673 #undef VEC4_PRECISION
674 #undef QUAT_PRECISION
675 #undef MAT3_PRECISION
676 #undef MAT4_PRECISION
677
678
679#endif // use vGizmoMath
680#if !defined(VGM_DISABLE_AUTO_NAMESPACE) || defined(VGIZMO_H_FILE)
681 using namespace VGM_NAMESPACE;
682#endif
683
684#undef VGM_NAMESPACE
685#undef T // if used T as #define, undef it
unsigned int uint
Definition VkReduce.h:5
Mat3(const MAT3_T &)=default
Mat3 operator*(const Mat3 &m) const
Definition vgMath.h:292
Mat3 & operator*=(const Mat3 &m)
Definition vgMath.h:287
Mat3 operator+(const Mat3 &m) const
Definition vgMath.h:289
Mat3 operator-(const Mat3 &m) const
Definition vgMath.h:290
Mat3 operator*(T s) const
Definition vgMath.h:302
Mat3(T s)
Definition vgMath.h:270
Mat3 operator/(T s) const
Definition vgMath.h:303
Mat3(const VEC3_T &v0, const VEC3_T &v1, const VEC3_T &v2)
Definition vgMath.h:271
VEC3_T v[3]
Definition vgMath.h:262
const VEC3_T & operator[](int i) const
Definition vgMath.h:277
VEC3_T operator*(const VEC3_T &v) const
Definition vgMath.h:305
Mat3()=default
Mat3 & operator*=(T s)
Definition vgMath.h:285
VEC3_T & operator[](int i)
Definition vgMath.h:278
Mat3(T v0x, T v0y, T v0z, T v1x, T v1y, T v1z, T v2x, T v2y, T v2z)
Definition vgMath.h:273
Mat3 & operator+=(const Mat3 &m)
Definition vgMath.h:282
Mat3 & operator-=(const Mat3 &m)
Definition vgMath.h:283
Mat3(const MAT4_T &m)
Mat3 & operator/=(const Mat3 &m)
Definition vgMath.h:284
Mat3 operator-() const
Definition vgMath.h:280
Mat3 & operator/=(T s)
Definition vgMath.h:286
Mat4(const VEC4_T &v0, const VEC4_T &v1, const VEC4_T &v2, const VEC4_T &v3)
Definition vgMath.h:325
Mat4 operator/(T s) const
Definition vgMath.h:347
Mat4 operator+(const Mat4 &m) const
Definition vgMath.h:344
Mat4 & operator+=(const Mat4 &m)
Definition vgMath.h:337
Mat4 & operator/=(const Mat4 &m)
Definition vgMath.h:339
Mat4(const MAT3_T &m)
Definition vgMath.h:326
Mat4()=default
Mat4 operator*(const Mat4 &m) const
Definition vgMath.h:349
Mat4 operator-() const
Definition vgMath.h:335
VEC4_T v[4]
Definition vgMath.h:316
Mat4 & operator*=(const Mat4 &m)
Definition vgMath.h:342
const VEC4_T & operator[](int i) const
Definition vgMath.h:332
VEC4_T operator*(const VEC4_T &v) const
Definition vgMath.h:366
Mat4(T s)
Definition vgMath.h:324
Mat4 & operator*=(T s)
Definition vgMath.h:340
Mat4 operator-(const Mat4 &m) const
Definition vgMath.h:345
Mat4 & operator/=(T s)
Definition vgMath.h:341
Mat4 & operator-=(const Mat4 &m)
Definition vgMath.h:338
Mat4 operator*(T s) const
Definition vgMath.h:346
Mat4(T v0x, T v0y, T v0z, T v0w, T v1x, T v1y, T v1z, T v1w, T v2x, T v2y, T v2z, T v2w, T v3x, T v3y, T v3z, T v3w)
Definition vgMath.h:327
VEC4_T & operator[](int i)
Definition vgMath.h:333
Quat(const QUAT_T &)=default
Quat & operator*=(T s)
Definition vgMath.h:238
Quat operator/(T s) const
Definition vgMath.h:249
Quat operator-() const
Definition vgMath.h:233
Quat & operator+=(const Quat &q)
Definition vgMath.h:235
Quat(T s, const VEC3_T &v)
Definition vgMath.h:231
Quat & operator/=(T s)
Definition vgMath.h:239
Quat operator-(const Quat &q) const
Definition vgMath.h:242
Quat & operator*=(const Quat &q)
Definition vgMath.h:237
Quat()=default
Quat operator+(const Quat &q) const
Definition vgMath.h:241
Quat & operator-=(const Quat &q)
Definition vgMath.h:236
T & operator[](int i)
Definition vgMath.h:252
Quat operator*(T s) const
Definition vgMath.h:248
const T & operator[](int i) const
Definition vgMath.h:251
Quat operator*(const Quat &q) const
Definition vgMath.h:243
Quat(T w, T x, T y, T z)
Definition vgMath.h:230
Vec2 & operator*=(T s)
Definition vgMath.h:128
const T & operator[](int i) const
Definition vgMath.h:138
Vec2 & operator/=(T s)
Definition vgMath.h:129
Vec2 operator*(T s) const
Definition vgMath.h:135
Vec2(T s)
Definition vgMath.h:119
Vec2 operator+(const Vec2 &v) const
Definition vgMath.h:131
Vec2 & operator/=(const Vec2 &v)
Definition vgMath.h:127
Vec2 & operator-=(const Vec2 &v)
Definition vgMath.h:125
Vec2 & operator+=(const Vec2 &v)
Definition vgMath.h:124
T & operator[](int i)
Definition vgMath.h:139
Vec2 operator/(const Vec2 &v) const
Definition vgMath.h:134
Vec2 operator*(const Vec2 &v) const
Definition vgMath.h:133
Vec2()=default
Vec2 operator-(const Vec2 &v) const
Definition vgMath.h:132
Vec2 & operator*=(const Vec2 &v)
Definition vgMath.h:126
Vec2(T x, T y)
Definition vgMath.h:120
Vec2 operator-() const
Definition vgMath.h:122
Vec2(const VEC2_T &)=default
Vec2 operator/(T s) const
Definition vgMath.h:136
Vec3 operator+(const Vec3 &v) const
Definition vgMath.h:170
Vec3 & operator+=(const Vec3 &v)
Definition vgMath.h:163
Vec3 & operator*=(T s)
Definition vgMath.h:167
Vec3 & operator/=(const Vec3 &v)
Definition vgMath.h:166
Vec3(const VEC3_T &)=default
T & operator[](int i)
Definition vgMath.h:178
Vec3(T s)
Definition vgMath.h:155
Vec3(T x, T y, T z)
Definition vgMath.h:156
Vec3 operator/(T s) const
Definition vgMath.h:175
Vec3 operator*(const Vec3 &v) const
Definition vgMath.h:172
Vec3 & operator-=(const Vec3 &v)
Definition vgMath.h:164
Vec3 & operator/=(T s)
Definition vgMath.h:168
Vec3(const VEC4_T &v)
Vec3(T s, const VEC2_T &v)
Definition vgMath.h:157
Vec3 operator*(T s) const
Definition vgMath.h:174
Vec3()=default
Vec3 operator-(const Vec3 &v) const
Definition vgMath.h:171
Vec3 & operator*=(const Vec3 &v)
Definition vgMath.h:165
Vec3(const VEC2_T &v, T s)
Definition vgMath.h:158
const T & operator[](int i) const
Definition vgMath.h:177
Vec3 operator-() const
Definition vgMath.h:161
Vec3 operator/(const Vec3 &v) const
Definition vgMath.h:173
Vec4(T s)
Definition vgMath.h:194
Vec4()=default
Vec4 & operator-=(const Vec4 &v)
Definition vgMath.h:203
Vec4 operator+(const Vec4 &v) const
Definition vgMath.h:209
Vec4 operator*(T s) const
Definition vgMath.h:213
Vec4 operator*(const Vec4 &v) const
Definition vgMath.h:211
Vec4 & operator*=(const Vec4 &v)
Definition vgMath.h:204
Vec4 operator-(const Vec4 &v) const
Definition vgMath.h:210
Vec4 & operator/=(T s)
Definition vgMath.h:207
Vec4 & operator/=(const Vec4 &v)
Definition vgMath.h:205
Vec4 & operator+=(const Vec4 &v)
Definition vgMath.h:202
Vec4(const VEC4_T &)=default
Vec4(T x, T y, T z, T w)
Definition vgMath.h:195
Vec4(T s, const VEC3_T &v)
Definition vgMath.h:197
Vec4 & operator*=(T s)
Definition vgMath.h:206
const T & operator[](int i) const
Definition vgMath.h:216
Vec4 operator/(const Vec4 &v) const
Definition vgMath.h:212
Vec4 operator-() const
Definition vgMath.h:200
Vec4 operator/(T s) const
Definition vgMath.h:214
T & operator[](int i)
Definition vgMath.h:217
Vec4(const VEC3_T &v, T s)
Definition vgMath.h:196
#define T(t)
Definition vgMath.h:99
TEMPLATE_TYPENAME_T VEC2_T pow(const VEC2_T &b, const VEC2_T &e)
Definition vgMath.h:433
TEMPLATE_TYPENAME_T T one_over_pi()
Definition vgMath.h:520
TEMPLATE_TYPENAME_T T mix(const T x, const T y, const T a)
Definition vgMath.h:427
TEMPLATE_TYPENAME_T MAT3_T mat3_cast(QUAT_T const &q)
Definition vgMath.h:377
float uintBitsToFloat(uint32_t const v)
Definition vgMath.h:386
TEMPLATE_TYPENAME_T MAT4_T translate(MAT4_T const &m, VEC3_T const &v)
Definition vgMath.h:503
TEMPLATE_TYPENAME_T T degrees(T r)
Definition vgMath.h:518
TEMPLATE_TYPENAME_T VEC3_T axis(QUAT_T const &q)
Definition vgMath.h:512
TEMPLATE_TYPENAME_T VEC2_T operator*(const T s, const VEC2_T &v)
Definition vgMath.h:487
TEMPLATE_TYPENAME_T T distance(const VEC2_T &v0, const VEC2_T &v1)
Definition vgMath.h:406
TEMPLATE_TYPENAME_T MAT4_T perspectiveFov(T fovy, T w, T h, T n, T f)
Definition vgMath.h:564
uint32_t floatBitsToUint(float const v)
Definition vgMath.h:387
TEMPLATE_TYPENAME_T VEC2_T operator/(const T s, const VEC2_T &v)
Definition vgMath.h:492
TEMPLATE_TYPENAME_T T tAbs(T x)
Definition vgMath.h:411
TEMPLATE_TYPENAME_T MAT4_T scale(MAT4_T const &m, VEC3_T const &v)
Definition vgMath.h:506
TEMPLATE_TYPENAME_T T dot(const VEC2_T &v0, const VEC2_T &v1)
Definition vgMath.h:390
TEMPLATE_TYPENAME_T MAT3_T transpose(MAT3_T m)
Definition vgMath.h:446
TEMPLATE_TYPENAME_T MAT4_T frustum(T l, T r, T b, T t, T n, T f)
Definition vgMath.h:567
TEMPLATE_TYPENAME_T MAT4_T perspective(T fovy, T a, T n, T f)
Definition vgMath.h:550
TEMPLATE_TYPENAME_T MAT4_T lookAt(const VEC3_T &pov, const VEC3_T &tgt, const VEC3_T &up)
Definition vgMath.h:524
TEMPLATE_TYPENAME_T VEC2_T normalize(const VEC2_T &v)
Definition vgMath.h:421
TEMPLATE_TYPENAME_T MAT4_T ortho(T l, T r, T b, T t, T n, T f)
Definition vgMath.h:537
TEMPLATE_TYPENAME_T T * value_ptr(const VEC2_T &v)
Definition vgMath.h:438
TEMPLATE_TYPENAME_T T angle(QUAT_T const &q)
Definition vgMath.h:511
TEMPLATE_TYPENAME_T MAT4_T mat4_cast(QUAT_T const &q)
Definition vgMath.h:385
TEMPLATE_TYPENAME_T QUAT_T angleAxis(T const &a, VEC3_T const &v)
Definition vgMath.h:510
TEMPLATE_TYPENAME_T T cross(const VEC2_T &u, const VEC2_T &v)
Definition vgMath.h:396
TEMPLATE_TYPENAME_T T pi()
Definition vgMath.h:519
TEMPLATE_TYPENAME_T VEC2_T abs(const VEC2_T &v)
Definition vgMath.h:412
TEMPLATE_TYPENAME_T QUAT_T inverse(QUAT_T const &q)
Definition vgMath.h:458
TEMPLATE_TYPENAME_T T sign(const T v)
Definition vgMath.h:418
TEMPLATE_TYPENAME_T T radians(T d)
Definition vgMath.h:517
TEMPLATE_TYPENAME_T T length(const VEC2_T &v)
Definition vgMath.h:400
vgm::Quat quat
Definition vgMath.h:633
vgm::VEC3_PRECISION tVec3
Definition vgMath.h:650
#define VEC4_T
Definition vgMath.h:83
#define VEC3_T
Definition vgMath.h:82
vgm::Vec3 vec3
Definition vgMath.h:631
vgm::QUAT_PRECISION tQuat
Definition vgMath.h:652
#define MAT4_T
Definition vgMath.h:86
vgm::VEC4_PRECISION tVec4
Definition vgMath.h:651
uint32_t uint32
Definition vgMath.h:660
vgm::Vec2 vec2
Definition vgMath.h:630
int8_t int8
Definition vgMath.h:657
vgm::Mat4 mat4
Definition vgMath.h:635
vgm::VEC2_PRECISION tVec2
Definition vgMath.h:649
#define M(X, Y)
Definition vgMath.h:291
#define VEC2_T
Definition vgMath.h:81
vgm::Mat3 mat3
Definition vgMath.h:634
#define TEMPLATE_TYPENAME_T
Definition vgMath.h:79
uint8_t uint8
Definition vgMath.h:656
#define VGM_NAMESPACE
Definition vgMath.h:56
mat3 mat3x3
Definition vgMath.h:636
#define MAT3_T
Definition vgMath.h:85
uint64_t uint64
Definition vgMath.h:662
int64_t int64
Definition vgMath.h:661
mat4 mat4x4
Definition vgMath.h:637
vgm::MAT3_PRECISION tMat3
Definition vgMath.h:653
vgm::MAT4_PRECISION tMat4
Definition vgMath.h:654
int32_t int32
Definition vgMath.h:659
#define QUAT_T
Definition vgMath.h:84
vgm::Vec4 vec4
Definition vgMath.h:632