mal-math
C++20 mathematics library.
•All Classes Namespaces Files Functions Variables Typedefs Concepts
mat_math.inl
Go to the documentation of this file.
1#pragma once
2#include "mat_math.hpp"
3#pragma warning(push)
4#pragma warning(disable : 4701)
5namespace mal_math
6{
7 template <AnyMat U>
8 constexpr std::istream &operator>>(std::istream &is, U &matrix)
9 {
10 for (size_t i = 0; i < U::size.x; i++)
11 {
12 for (size_t j = 0; j < U::size.y; j++)
13 {
14 is >> matrix[i][j];
15 }
16 }
17 return is;
18 }
19 template <AnyMat U>
20 constexpr std::ostream &operator<<(std::ostream &os, U const &matrix)
21 {
22 for (size_t i = 0; i < U::size.x; i++)
23 {
24 for (size_t j = 0; j < U::size.y; j++)
25 {
26 os << matrix[i][j] << " ";
27 }
28 os << std::endl;
29 }
30 return os;
31 }
32 template <AnyMat U, AnyMat V>
33 [[nodiscard]] constexpr auto operator*(U const &lhs, V const &rhs) requires (U::size.x == V::size.y)
34 {
35 using T = decltype(lhs[0][0] * rhs[0][0]);
36 using R = mat<V::size.x, U::size.y, T>;
37 R result;
38 for (size_t i = 0; i < V::size.x; i++)
39 {
40 for (size_t j = 0; j < U::size.y; j++)
41 {
42 T sum = 0;
43 for (size_t k = 0; k < V::size.y; k++)
44 {
45 sum += lhs[k][j] * rhs[i][k];
46 }
47 result[i][j] = sum;
48 }
49 }
50 return result;
51 }
52
53 template <AnyVec V, AnyMat M>
54 [[nodiscard]] constexpr auto operator*(V const &left, M const &right) requires (V::size == M::size.y)
55 {
56 using T = decltype(left[0] * right[0][0]);
57 using R = vec<M::size.x, T>;
58 R result;
59 for (size_t i = 0; i < M::size.x; i++)
60 {
61 T sum = 0;
62 for (size_t j = 0; j < M::size.y; j++)
63 {
64 sum += left[j] * right[i][j];
65 }
66 result[i] = sum;
67 }
68 return result;
69 }
70 template <AnyMat M, AnyVec V>
71 [[nodiscard]] constexpr auto operator*(M const &left, V const &right) requires (M::size.x == V::size)
72 {
73 using T = decltype(left[0][0] * right[0]);
74 using R = vec<M::size.y, T>;
75 R result;
76 for (size_t i = 0; i < M::size.y; i++)
77 {
78 T sum = 0;
79 for (size_t j = 0; j < M::size.x; j++)
80 {
81 sum += left[j][i] * right[j];
82 }
83 result[i] = sum;
84 }
85 return result;
86 }
87
88 template <AnyMat T, Primitive U>
89 [[nodiscard]] constexpr mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>> operator*(T const &left, U const right)
90 {
91 return mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>>(left) *= right;
92 }
93 template <AnyMat T, Primitive U>
94 [[nodiscard]] constexpr mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>> operator*(U const left, T const &right)
95 {
96 return mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>>(right) *= left;
97 }
98
99 template <AnyMat T, Primitive U>
100 [[nodiscard]] constexpr mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>> operator-(T const &left, U const right)
101 {
102 return mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>>(left) -= right;
103 }
104 template <AnyMat T, Primitive U>
105 [[nodiscard]] constexpr mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>> operator+(U const left, T const &right)
106 {
107 return mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>>(left) += right;
108 }
109
110 template <AnyMat T, AnyMat U>
111 [[nodiscard]] constexpr mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>> operator-(T const left, U const &right) requires(T::size.x == U::size.x && T::size.y == U::size.y)
112 {
113 return mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>>(left) -= right;
114 }
115 template <AnyMat T, AnyMat U>
116 [[nodiscard]] constexpr mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>> operator+(T const &left, U const &right) requires(T::size.x == U::size.x && T::size.y == U::size.y)
117 {
118 return mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>>(left) += right;
119 }
120 template <AnyMat T>
121 constexpr mat<T::size.y, T::size.x, std::remove_const_t<typename T::type>> transpose(T const &matrix)
122 {
123 mat<T::size.y, T::size.x, std::remove_const_t<typename T::type>> return_value;
124 for (size_t i = 0; i < T::size.x; i++)
125 {
126 for (size_t j = 0; j < T::size.y; j++)
127 {
128 return_value[j][i] = matrix[i][j];
129 }
130 }
131 return return_value;
132 }
133 template <AnyMat T>
134 constexpr rmat<T::size.y, T::size.x, typename T::type> rtranspose(T &matrix)
135 {
136 rmat<T::size.y, T::size.x, typename T::type> return_value;
137 for (size_t i = 0; i < T::size.x; i++)
138 {
139 for (size_t j = 0; j < T::size.y; j++)
140 {
141 return_value.arr[j * T::size.x + i].set_ptr(matrix[i][j]);
142 }
143 }
144 return return_value;
145 }
146 template <AnyMat T>
147 constexpr rmat<T::size.y, T::size.x, const typename T::type> rctranspose(T const &matrix)
148 {
149 rmat<T::size.y, T::size.x, const typename T::type> return_value;
150 for (size_t i = 0; i < T::size.x; i++)
151 {
152 for (size_t j = 0; j < T::size.y; j++)
153 {
154 return_value.arr[j * T::size.x + i].set_ptr(matrix[i][j]);
155 }
156 }
157 return return_value;
158 }
159
160 template <AnyMat T>
161 constexpr typename T::type det_2(T const &m) requires(T::size.x == T::size.y && T::size.x == 2)
162 {
163 return m[0][0] * m[1][1] - m[1][0] * m[0][1];
164 }
165 template <AnyMat T>
166 constexpr typename T::type det_3(T const &m) requires(T::size.x == T::size.y && T::size.x == 3)
167 {
168 return +m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2]) - m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2]) + m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
169 }
170 template <AnyMat T>
171 constexpr typename T::type det_4(T const &m) requires(T::size.x == T::size.y && T::size.x == 4)
172 {
173 typename T::type const sub_det_00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
174 typename T::type const sub_det_01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
175 typename T::type const sub_det_02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
176 typename T::type const sub_det_03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
177 typename T::type const sub_det_04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
178 typename T::type const sub_det_05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
179
180 vec<4, typename T::type> sub_det(
181 +(m[1][1] * sub_det_00 - m[1][2] * sub_det_01 + m[1][3] * sub_det_02),
182 -(m[1][0] * sub_det_00 - m[1][2] * sub_det_03 + m[1][3] * sub_det_04),
183 +(m[1][0] * sub_det_01 - m[1][1] * sub_det_03 + m[1][3] * sub_det_05),
184 -(m[1][0] * sub_det_02 - m[1][1] * sub_det_04 + m[1][2] * sub_det_05));
185
186 return m[0][0] * sub_det[0] + m[0][1] * sub_det[1] + m[0][2] * sub_det[2] +
187 m[0][3] * sub_det[3];
188 }
189
190 template <AnyMat T>
191 constexpr typename T::type det(T const &m) requires(T::size.x == T::size.y)
192 {
193 if constexpr (T::size.x == 1)
194 return m[0][0];
195 if constexpr (T::size.x == 2)
196 return det_2(m);
197 if constexpr (T::size.x == 3)
198 return det_3(m);
199 if constexpr (T::size.x == 4)
200 return det_4(m);
201 }
202 template <AnyMat T>
203 constexpr typename T::type determinant(T const &matrix) requires(T::size.x == T::size.y)
204 {
205 return det(matrix);
206 }
207
208 template <AnyMat T>
209 constexpr mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>> adj(T const &m) requires(T::size.x == T::size.y)
210 {
211 mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>> return_value;
212 for (size_t i = 0; i < T::size.x; i++)
213 {
214 for (size_t j = 0; j < T::size.y; j++)
215 {
216 mat<T::size.x - 1, T::size.y - 1, std::remove_const_t<typename T::type>> sub_matrix;
217 for (size_t k = 0; k < T::size.x; k++)
218 {
219 for (size_t l = 0; l < T::size.y; l++)
220 {
221 if (k != i && l != j)
222 {
223 sub_matrix[k < i ? k : k - 1][l < j ? l : l - 1] = m[k][l];
224 }
225 }
226 }
227 return_value[j][i] = det(sub_matrix) * ((i + j) % 2 == 0 ? 1 : -1);
228 }
229 }
230 return return_value;
231 }
232 // calculate an adjugate for a matrix
233 template <AnyMat T>
234 constexpr mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>> adjugate(T const &m) requires(T::size.x == T::size.y)
235 {
236 return adj(m);
237 }
238
239 template <AnyMat T>
240 constexpr mat<T::size.x, T::size.y, std::remove_const_t<typename T::type>> inverse(T const &m) requires(T::size.x == T::size.y)
241 {
242 return adjugate(m) * (static_cast<typename T::type>(1) / det(m));
243 }
244
245 template <AnyMat T, AnyVec V>
246 constexpr mat<4, 4, std::remove_const_t<typename T::type>> translate(T const &matrix, V const &vec) requires(T::size.x == T::size.y && T::size.x == 4 && V::size == 3)
247 {
248 mat<4, 4, typename T::type> return_value;
249 return_value[0] = matrix[0];
250 return_value[1] = matrix[1];
251 return_value[2] = matrix[2];
252 return_value[3] = matrix[0] * vec[0] + matrix[1] * vec[1] + matrix[2] * vec[2] + matrix[3];
253 return return_value;
254 }
255 template <AnyMat T, Primitive U, AnyVec V>
256 constexpr mat<4, 4, std::remove_const_t<typename T::type>> rotate(T const &matrix, U angle, V const &vector) requires(T::size.x == T::size.y && T::size.x == 4 && V::size == 3)
257 {
258 typename T::type const c = std::cos(angle);
259 typename T::type const s = std::sin(angle);
260 vec<3, typename T::type> axis = normalize(vector);
261 vec<3, typename T::type> temp = (static_cast<typename T::type>(1) - c) * axis;
262 mat<4, 4, typename T::type> rotate;
263
264 rotate[0][0] = c + temp[0] * axis[0];
265 rotate[0][1] = temp[0] * axis[1] + s * axis[2];
266 rotate[0][2] = temp[0] * axis[2] - s * axis[1];
267
268 rotate[1][0] = temp[1] * axis[0] - s * axis[2];
269 rotate[1][1] = c + temp[1] * axis[1];
270 rotate[1][2] = temp[1] * axis[2] + s * axis[0];
271
272 rotate[2][0] = temp[2] * axis[0] + s * axis[1];
273 rotate[2][1] = temp[2] * axis[1] - s * axis[0];
274 rotate[2][2] = c + temp[2] * axis[2];
275
276 mat<4, 4, typename T::type> result(1);
277 result[0] = matrix[0] * rotate[0][0] + matrix[1] * rotate[0][1] +
278 matrix[2] * rotate[0][2];
279 result[1] = matrix[0] * rotate[1][0] + matrix[1] * rotate[1][1] +
280 matrix[2] * rotate[1][2];
281 result[2] = matrix[0] * rotate[2][0] + matrix[1] * rotate[2][1] +
282 matrix[2] * rotate[2][2];
283 result[3] = matrix[3];
284 return result;
285 }
286 template <AnyMat T, AnyVec V>
287 constexpr mat<4, 4, std::remove_const_t<typename T::type>> scale(T const &matrix, V const &scale) requires(T::size.x == T::size.y && T::size.x == 4 && V::size == 3)
288 {
289 mat<4, 4, typename T::type> return_value;
290 return_value[0] = matrix[0] * scale[0];
291 return_value[1] = matrix[1] * scale[1];
292 return_value[2] = matrix[2] * scale[2];
293 return_value[3] = matrix[3];
294 return return_value;
295 }
296
297 template <AnyVec Position>
298 constexpr mat<4, 4, std::remove_const_t<typename Position::type>> look_at(Position const &eye, Position const &center, Position const &world_up) requires(Position::size == 3)
299 {
300 vec<3, typename Position::type> const forward = normalize(center - eye);
301 vec<3, typename Position::type> const right = normalize(cross(world_up, forward));
302 vec<3, typename Position::type> const up = cross(forward, right);
303 mat<4, 4, typename Position::type> return_value(1);
304 return_value[0][0] = right.x;
305 return_value[1][0] = right.y;
306 return_value[2][0] = right.z;
307 return_value[0][1] = up.x;
308 return_value[1][1] = up.y;
309 return_value[2][1] = up.z;
310 return_value[0][2] = forward.x;
311 return_value[1][2] = forward.y;
312 return_value[2][2] = forward.z;
313 return_value[3][0] = -dot(right, eye);
314 return_value[3][1] = -dot(up, eye);
315 return_value[3][2] = -dot(forward, eye);
316 return return_value;
317 }
318 template <Primitive T>
319 constexpr mat<4, 4, T> perspective(T fov_y, T aspect_ratio, T z_near, T z_far) requires(!std::numeric_limits<T>::is_integer)
320 {
321 assert(std::abs(aspect_ratio - std::numeric_limits<T>::epsilon()) >
322 static_cast<T>(0));
323
324 T const tan_half_fov_y = tan(fov_y / static_cast<T>(2));
325
326 mat<4, 4, T> return_value(0);
327 return_value[0][0] = static_cast<T>(1) / (aspect_ratio * tan_half_fov_y);
328 return_value[1][1] = static_cast<T>(1) / tan_half_fov_y;
329 return_value[2][2] = z_far / (z_far - z_near);
330 return_value[2][3] = static_cast<T>(1);
331 return_value[3][2] = -(z_far * z_near) / (z_far - z_near);
332 return return_value;
333 }
334
335 template <Primitive T>
336 constexpr mat<4, 4, T> ortho(T left, T right, T bottom, T top, T zNear, T zFar)
337 {
338 mat<4, 4, T> Result(1);
339 Result[0][0] = static_cast<T>(2) / (right - left);
340 Result[1][1] = static_cast<T>(2) / (top - bottom);
341 Result[2][2] = static_cast<T>(1) / (zFar - zNear);
342 Result[3][0] = -(right + left) / (right - left);
343 Result[3][1] = -(top + bottom) / (top - bottom);
344 Result[3][2] = -zNear / (zFar - zNear);
345 return Result;
346 }
347
348 template <Primitive T>
349 constexpr void invert_orthonormal(mat<4, 4, T> const &src, mat<4, 4, T> &dst)
350 {
351 assert(&src != &dst);
352 dst[0][0] = src[0][0];
353 dst[1][1] = src[1][1];
354 dst[2][2] = src[2][2];
355 dst[0][1] = src[1][0];
356 dst[1][0] = src[0][1];
357 dst[0][2] = src[2][0];
358 dst[2][0] = src[0][2];
359 dst[1][2] = src[2][1];
360 dst[2][1] = src[1][2];
361 as_rvec<3>(dst[3]) =
362 -src[3].x * as_rvec<3>(dst.data[0]) - src[3].y * as_rvec<3>(dst.data[1]) - src[3].z * as_rvec<3>(dst.data[2]);
363 dst[0][3] = 0;
364 dst[1][3] = 0;
365 dst[2][3] = 0;
366 dst[3][3] = 1;
367 }
368 template <Primitive T>
369 constexpr void invert_orthogonal(mat<4, 4, T> const &src, mat<4, 4, T> &dst)
370 {
371 assert(&src != &dst);
372 dst[0][0] = src[0][0];
373 dst[1][1] = src[1][1];
374 dst[2][2] = src[2][2];
375 dst[0][1] = src[1][0];
376 dst[1][0] = src[0][1];
377 dst[0][2] = src[2][0];
378 dst[2][0] = src[0][2];
379 dst[1][2] = src[2][1];
380 dst[2][1] = src[1][2];
381
382 vec3 lengths{
383 sqrt(dst[0][0] * dst[0][0] + dst[0][1] * dst[0][1] +
384 dst[0][2] * dst[0][2]),
385 sqrt(dst[1][0] * dst[1][0] + dst[1][1] * dst[1][1] +
386 dst[1][2] * dst[1][2]),
387 sqrt(dst[2][0] * dst[2][0] + dst[2][1] * dst[2][1] +
388 dst[2][2] * dst[2][2]),
389 };
390
391 dst[0][0] = 1.0f / (dst[0][0] * lengths[0]);
392 dst[0][1] = 1.0f / (dst[0][1] * lengths[0]);
393 dst[0][2] = 1.0f / (dst[0][2] * lengths[0]);
394 dst[1][0] = 1.0f / (dst[1][0] * lengths[1]);
395 dst[1][1] = 1.0f / (dst[1][1] * lengths[1]);
396 dst[1][2] = 1.0f / (dst[1][2] * lengths[1]);
397 dst[2][0] = 1.0f / (dst[2][0] * lengths[2]);
398 dst[2][1] = 1.0f / (dst[2][1] * lengths[2]);
399 dst[2][2] = 1.0f / (dst[2][2] * lengths[2]);
400
401 dst[3][0] = -src[3].x * dst.data[0][0] / lengths[0] -
402 src[3].x * dst.data[0][1] / lengths[0] -
403 src[3].x * dst.data[0][2] / lengths[0];
404 dst[3][1] = -src[3].y * dst.data[1][0] / lengths[1] -
405 src[3].y * dst.data[1][1] / lengths[1] -
406 src[3].y * dst.data[1][2] / lengths[1];
407 dst[3][2] = -src[3].z * dst.data[2][0] / lengths[2] -
408 src[3].z * dst.data[2][1] / lengths[2] -
409 src[3].z * dst.data[2][2] / lengths[2];
410 dst[0][3] = 0;
411 dst[1][3] = 0;
412 dst[2][3] = 0;
413 dst[3][3] = 1;
414 }
415 template <Primitive T>
416 constexpr mat<4, 4, T> invert_orthonormal(mat<4, 4, T> const &src)
417 {
418 mat<4, 4, T> return_value;
419 invert_orthonormal(src, return_value);
420 return return_value;
421 }
422 template <Primitive T>
423 constexpr mat<4, 4, T> invert_orthogonal(mat<4, 4, T> const &src)
424 {
425 mat<4, 4, T> return_value;
426 invert_orthogonal(src, return_value);
427 return return_value;
428 }
429} // namespace mal_math
430#pragma warning(pop)
mat_math.hpp
Defines various matrix mathematical operations.
mal_math
Contains mathematical utility functions and classes.
mal_math::det
constexpr T::type det(T const &matrix)
Calculates the determinant of a square matrix.
Definition mat_math.inl:191
mal_math::invert_orthonormal
constexpr void invert_orthonormal(mat< 4, 4, T > const &src, mat< 4, 4, T > &dst)
Inverts an orthonormal matrix in-place and stores the result in a destination matrix.
Definition mat_math.inl:349
mal_math::perspective
constexpr mat< 4, 4, T > perspective(T fov_y, T aspect_ratio, T z_near, T z_far)
Generates a perspective projection matrix.
Definition mat_math.inl:319
mal_math::rotate
constexpr mat< 4, 4, std::remove_const_t< typename T::type > > rotate(T const &matrix, U angle, V const &axis)
Rotates a matrix by a given angle around a given axis.
Definition mat_math.inl:256
mal_math::rtranspose
constexpr rmat< T::size.y, T::size.x, typename T::type > rtranspose(T &matrix)
Transposes a matrix and returns a reference to it.
Definition mat_math.inl:134
mal_math::translate
constexpr mat< 4, 4, std::remove_const_t< typename T::type > > translate(T const &matrix, V const &vec)
Translates a matrix by a given vector.
Definition mat_math.inl:246
mal_math::invert_orthogonal
constexpr void invert_orthogonal(mat< 4, 4, T > const &src, mat< 4, 4, T > &dst)
Inverts an orthogonal matrix in-place and stores the result in a destination matrix.
Definition mat_math.inl:369
mal_math::det_2
constexpr T::type det_2(T const &m)
Definition mat_math.inl:161
mal_math::operator-
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > operator-(T const &left, U const right)
Subtracts a matrix from a primitive.
Definition mat_math.inl:100
mal_math::angle
constexpr T angle(qua< T > const &quaternion) noexcept
Computes the angle (or magnitude) of a quaternion.
Definition quaternion.inl:238
mal_math::ortho
constexpr mat< 4, 4, T > ortho(T left, T right, T bottom, T top, T zNear, T zFar)
Generates an orthographic projection matrix.
Definition mat_math.inl:336
mal_math::operator*
constexpr auto operator*(U const &lhs, V const &rhs)
Multiplies two matrices.
Definition mat_math.inl:33
mal_math::det_3
constexpr T::type det_3(T const &m)
Definition mat_math.inl:166
mal_math::adj
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > adj(T const &m)
Computes the adjoint (or adjugate) of a square matrix.
Definition mat_math.inl:209
mal_math::det_4
constexpr T::type det_4(T const &m)
Definition mat_math.inl:171
mal_math::determinant
constexpr T::type determinant(T const &matrix)
Calculates the determinant of a square matrix.
Definition mat_math.inl:203
mal_math::sqrt
float sqrt(T x) noexcept
Definition math-common.hpp:302
mal_math::operator>>
constexpr std::istream & operator>>(std::istream &is, U &matrix)
Reads a matrix from an input stream.
Definition mat_math.inl:8
mal_math::inverse
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > inverse(T const &matrix)
Calculates the inverse of a square matrix.
Definition mat_math.inl:240
mal_math::operator<<
constexpr std::ostream & operator<<(std::ostream &os, U const &matrix)
Writes a matrix to an output stream.
Definition mat_math.inl:20
mal_math::dot
constexpr T dot(qua< T > const &left, qua< U > const &right) noexcept
Computes the dot product of two quaternions.
Definition quaternion.inl:227
mal_math::transpose
constexpr mat< T::size.y, T::size.x, std::remove_const_t< typename T::type > > transpose(T const &matrix)
Transposes a matrix.
Definition mat_math.inl:121
mal_math::scale
constexpr mat< 4, 4, std::remove_const_t< typename T::type > > scale(T const &matrix, V const &scale)
Scales a matrix by a given vector.
Definition mat_math.inl:287
mal_math::normalize
constexpr qua< T > normalize(qua< T > const &q) noexcept
Normalizes a quaternion.
Definition quaternion.inl:408
mal_math::operator+
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > operator+(U const left, T const &right)
Adds a matrix to a primitive.
Definition mat_math.inl:105
mal_math::tan
float tan(T x) noexcept
Definition math-common.hpp:226
mal_math::adjugate
constexpr mat< T::size.x, T::size.y, std::remove_const_t< typename T::type > > adjugate(T const &m)
Alias for the adj() function to compute the adjugate of a matrix.
Definition mat_math.inl:234
mal_math::as_rvec
constexpr vec< n, typename Vector::type > & as_rvec(Vector &v) noexcept
Convert a given vector to a reference of vec with specified size and type.
Definition vec_math.inl:56
mal_math::look_at
constexpr mat< 4, 4, std::remove_const_t< typename Position::type > > look_at(Position const &eye, Position const &center, Position const &up)
Generates a look-at matrix for camera positioning.
Definition mat_math.inl:298
mal_math::cross
constexpr vec< 3, T > cross(qua< T > const &left, vec< 3, U > const &right) noexcept
Cross product between quaternion and vector.
Definition quaternion.inl:293
mal_math::rctranspose
constexpr rmat< T::size.y, T::size.x, const typename T::type > rctranspose(T const &matrix)
Transposes a constant matrix and returns a constant reference to it.
Definition mat_math.inl:147
mal_math::mat
Definition of matrix with dimensions rows x columns and type T
Definition matnxn.hpp:39
mal_math::mat::data
std::array< vec< size.y, T >, size.x > data
2D array (rows x columns) representation of matrix data.
Definition matnxn.hpp:249
mal_math::rmat
Definition of a reference matrix with dimensions rows x columns and type T
Definition rmatnxn.hpp:45
mal_math::rmat::arr
std::array< _detail::primitive_reference_wrapper< T >, size.x *size.y > arr
Linear representation of the matrix.
Definition rmatnxn.hpp:136
mal_math::vec
Definition of the mathematical vector with fixed size L and type T
Definition vecn.hpp:22