| Flutter Impeller |

matrix.h
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef FLUTTER_IMPELLER_GEOMETRY_MATRIX_H_
6 #define FLUTTER_IMPELLER_GEOMETRY_MATRIX_H_
7
8 #include <cmath>
9 #include <iomanip>
10 #include <limits>
11 #include <optional>
12 #include <ostream>
13 #include <utility>
14
15 #include "impeller/geometry/matrix_decomposition.h"
16 #include "impeller/geometry/point.h"
17 #include "impeller/geometry/quaternion.h"
18 #include "impeller/geometry/scalar.h"
19 #include "impeller/geometry/shear.h"
20 #include "impeller/geometry/size.h"
21 #include "impeller/geometry/vector.h"
22
23 namespace impeller {
24
25 //------------------------------------------------------------------------------
26 /// @brief A 4x4 matrix using column-major storage.
27 ///
28 /// Utility methods that need to make assumptions about normalized
29 /// device coordinates must use the following convention:
30 /// * Left-handed coordinate system. Positive rotation is
31 /// clockwise about axis of rotation.
32 /// * Lower left corner is -1.0f, -1.0.
33 /// * Upper right corner is 1.0f, 1.0.
34 /// * Visible z-space is from 0.0 to 1.0.
35 /// * This is NOT the same as OpenGL! Be careful.
36 /// * NDC origin is at (0.0f, 0.0f, 0.5f).
37 struct Matrix {
38 union {
39 Scalar m[16];
40 Scalar e[4][4];
41 Vector4 vec[4];
42 };
43
44 //----------------------------------------------------------------------------
45 /// Constructs a default identity matrix.
46 ///
47 constexpr Matrix()
48 // clang-format off
49 : vec{ Vector4(1.0f, 0.0f, 0.0f, 0.0f),
50 Vector4(0.0f, 1.0f, 0.0f, 0.0f),
51 Vector4(0.0f, 0.0f, 1.0f, 0.0f),
52 Vector4(0.0f, 0.0f, 0.0f, 1.0f)} {}
53 // clang-format on
54
55 // clang-format off
56 constexpr Matrix(Scalar m0, Scalar m1, Scalar m2, Scalar m3,
57 Scalar m4, Scalar m5, Scalar m6, Scalar m7,
58 Scalar m8, Scalar m9, Scalar m10, Scalar m11,
59 Scalar m12, Scalar m13, Scalar m14, Scalar m15)
60 : vec{Vector4(m0, m1, m2, m3),
61 Vector4(m4, m5, m6, m7),
62 Vector4(m8, m9, m10, m11),
63 Vector4(m12, m13, m14, m15)} {}
64 // clang-format on
65
66 explicit Matrix(const MatrixDecomposition& decomposition);
67
68 // clang-format off
69 static constexpr Matrix MakeColumn(
70 Scalar m0, Scalar m1, Scalar m2, Scalar m3,
71 Scalar m4, Scalar m5, Scalar m6, Scalar m7,
72 Scalar m8, Scalar m9, Scalar m10, Scalar m11,
73 Scalar m12, Scalar m13, Scalar m14, Scalar m15){
74 return Matrix(m0, m1, m2, m3,
75 m4, m5, m6, m7,
76 m8, m9, m10, m11,
77 m12, m13, m14, m15);
78
79 }
80 // clang-format on
81
82 // clang-format off
83 static constexpr Matrix MakeRow(
84 Scalar m0, Scalar m1, Scalar m2, Scalar m3,
85 Scalar m4, Scalar m5, Scalar m6, Scalar m7,
86 Scalar m8, Scalar m9, Scalar m10, Scalar m11,
87 Scalar m12, Scalar m13, Scalar m14, Scalar m15){
88 return Matrix(m0, m4, m8, m12,
89 m1, m5, m9, m13,
90 m2, m6, m10, m14,
91 m3, m7, m11, m15);
92 }
93 // clang-format on
94
95 static constexpr Matrix MakeTranslation(const Vector3& t) {
96 // clang-format off
97 return Matrix(1.0f, 0.0f, 0.0f, 0.0f,
98 0.0f, 1.0f, 0.0f, 0.0f,
99 0.0f, 0.0f, 1.0f, 0.0f,
100 t.x, t.y, t.z, 1.0f);
101 // clang-format on
102 }
103
104 static constexpr Matrix MakeScale(const Vector3& s) {
105 // clang-format off
106 return Matrix(s.x, 0.0f, 0.0f, 0.0f,
107 0.0f, s.y, 0.0f, 0.0f,
108 0.0f, 0.0f, s.z, 0.0f,
109 0.0f, 0.0f, 0.0f, 1.0f);
110 // clang-format on
111 }
112
113 static constexpr Matrix MakeScale(const Vector2& s) {
114 return MakeScale(Vector3(s.x, s.y, 1.0f));
115 }
116
117 static constexpr Matrix MakeSkew(Scalar sx, Scalar sy) {
118 // clang-format off
119 return Matrix(1.0f, sy , 0.0f, 0.0f,
120 sx , 1.0f, 0.0f, 0.0f,
121 0.0f, 0.0f, 1.0f, 0.0f,
122 0.0f, 0.0f, 0.0f, 1.0f);
123 // clang-format on
124 }
125
126 static Matrix MakeRotation(Quaternion q) {
127 // clang-format off
128 return Matrix(
129 1.0f - 2.0f * q.y * q.y - 2.0f * q.z * q.z,
130 2.0f * q.x * q.y + 2.0f * q.z * q.w,
131 2.0f * q.x * q.z - 2.0f * q.y * q.w,
132 0.0f,
133
134 2.0f * q.x * q.y - 2.0f * q.z * q.w,
135 1.0f - 2.0f * q.x * q.x - 2.0f * q.z * q.z,
136 2.0f * q.y * q.z + 2.0f * q.x * q.w,
137 0.0f,
138
139 2.0f * q.x * q.z + 2.0f * q.y * q.w,
140 2.0f * q.y * q.z - 2.0f * q.x * q.w,
141 1.0f - 2.0f * q.x * q.x - 2.0f * q.y * q.y,
142 0.0f,
143
144 0.0f,
145 0.0f,
146 0.0f,
147 1.0f);
148 // clang-format on
149 }
150
151 static Matrix MakeRotation(Scalar radians, const Vector4& r) {
152 const Vector4 v = r.Normalize();
153
154 const Scalar cosine = cos(radians);
155 const Scalar cosp = 1.0f - cosine;
156 const Scalar sine = sin(radians);
157
158 // clang-format off
159 return Matrix(
160 cosine + cosp * v.x * v.x,
161 cosp * v.x * v.y + v.z * sine,
162 cosp * v.x * v.z - v.y * sine,
163 0.0f,
164
165 cosp * v.x * v.y - v.z * sine,
166 cosine + cosp * v.y * v.y,
167 cosp * v.y * v.z + v.x * sine,
168 0.0f,
169
170 cosp * v.x * v.z + v.y * sine,
171 cosp * v.y * v.z - v.x * sine,
172 cosine + cosp * v.z * v.z,
173 0.0f,
174
175 0.0f,
176 0.0f,
177 0.0f,
178 1.0f);
179 // clang-format on
180 }
181
182 static Matrix MakeRotationX(Radians r) {
183 const Scalar cosine = cos(r.radians);
184 const Scalar sine = sin(r.radians);
185 // clang-format off
186 return Matrix(
187 1.0f, 0.0f, 0.0f, 0.0f,
188 0.0f, cosine, sine, 0.0f,
189 0.0f, -sine, cosine, 0.0f,
190 0.0f, 0.0f, 0.0f, 1.0f
191 );
192 // clang-format on
193 }
194
195 static Matrix MakeRotationY(Radians r) {
196 const Scalar cosine = cos(r.radians);
197 const Scalar sine = sin(r.radians);
198
199 // clang-format off
200 return Matrix(
201 cosine, 0.0f, -sine, 0.0f,
202 0.0f, 1.0f, 0.0f, 0.0f,
203 sine, 0.0f, cosine, 0.0f,
204 0.0f, 0.0f, 0.0f, 1.0f
205 );
206 // clang-format on
207 }
208
209 static Matrix MakeRotationZ(Radians r) {
210 const Scalar cosine = cos(r.radians);
211 const Scalar sine = sin(r.radians);
212
213 // clang-format off
214 return Matrix (
215 cosine, sine, 0.0f, 0.0f,
216 -sine, cosine, 0.0f, 0.0f,
217 0.0f, 0.0f, 1.0f, 0.0f,
218 0.0f, 0.0f, 0.0f, 1.0
219 );
220 // clang-format on
221 }
222
223 /// The Matrix without its `w` components (without translation).
224 constexpr Matrix Basis() const {
225 // clang-format off
226 return Matrix(
227 m[0], m[1], m[2], 0.0f,
228 m[4], m[5], m[6], 0.0f,
229 m[8], m[9], m[10], 0.0f,
230 0.0f, 0.0f, 0.0f, 1.0
231 );
232 // clang-format on
233 }
234
235 constexpr Matrix Translate(const Vector3& t) const {
236 // clang-format off
237 return Matrix(m[0], m[1], m[2], m[3],
238 m[4], m[5], m[6], m[7],
239 m[8], m[9], m[10], m[11],
240 m[0] * t.x + m[4] * t.y + m[8] * t.z + m[12],
241 m[1] * t.x + m[5] * t.y + m[9] * t.z + m[13],
242 m[2] * t.x + m[6] * t.y + m[10] * t.z + m[14],
243 m[15]);
244 // clang-format on
245 }
246
247 constexpr Matrix Scale(const Vector3& s) const {
248 // clang-format off
249 return Matrix(m[0] * s.x, m[1] * s.x, m[2] * s.x, m[3] * s.x,
250 m[4] * s.y, m[5] * s.y, m[6] * s.y, m[7] * s.y,
251 m[8] * s.z, m[9] * s.z, m[10] * s.z, m[11] * s.z,
252 m[12] , m[13] , m[14] , m[15] );
253 // clang-format on
254 }
255
256 constexpr Matrix Multiply(const Matrix& o) const {
257 // clang-format off
258 return Matrix(
259 m[0] * o.m[0] + m[4] * o.m[1] + m[8] * o.m[2] + m[12] * o.m[3],
260 m[1] * o.m[0] + m[5] * o.m[1] + m[9] * o.m[2] + m[13] * o.m[3],
261 m[2] * o.m[0] + m[6] * o.m[1] + m[10] * o.m[2] + m[14] * o.m[3],
262 m[3] * o.m[0] + m[7] * o.m[1] + m[11] * o.m[2] + m[15] * o.m[3],
263 m[0] * o.m[4] + m[4] * o.m[5] + m[8] * o.m[6] + m[12] * o.m[7],
264 m[1] * o.m[4] + m[5] * o.m[5] + m[9] * o.m[6] + m[13] * o.m[7],
265 m[2] * o.m[4] + m[6] * o.m[5] + m[10] * o.m[6] + m[14] * o.m[7],
266 m[3] * o.m[4] + m[7] * o.m[5] + m[11] * o.m[6] + m[15] * o.m[7],
267 m[0] * o.m[8] + m[4] * o.m[9] + m[8] * o.m[10] + m[12] * o.m[11],
268 m[1] * o.m[8] + m[5] * o.m[9] + m[9] * o.m[10] + m[13] * o.m[11],
269 m[2] * o.m[8] + m[6] * o.m[9] + m[10] * o.m[10] + m[14] * o.m[11],
270 m[3] * o.m[8] + m[7] * o.m[9] + m[11] * o.m[10] + m[15] * o.m[11],
271 m[0] * o.m[12] + m[4] * o.m[13] + m[8] * o.m[14] + m[12] * o.m[15],
272 m[1] * o.m[12] + m[5] * o.m[13] + m[9] * o.m[14] + m[13] * o.m[15],
273 m[2] * o.m[12] + m[6] * o.m[13] + m[10] * o.m[14] + m[14] * o.m[15],
274 m[3] * o.m[12] + m[7] * o.m[13] + m[11] * o.m[14] + m[15] * o.m[15]);
275 // clang-format on
276 }
277
278 constexpr Matrix Transpose() const {
279 // clang-format off
280 return {
281 m[0], m[4], m[8], m[12],
282 m[1], m[5], m[9], m[13],
283 m[2], m[6], m[10], m[14],
284 m[3], m[7], m[11], m[15],
285 };
286 // clang-format on
287 }
288
289 Matrix Invert() const;
290
291 Scalar GetDeterminant() const;
292
293 Scalar GetMaxBasisLength() const;
294
295 Scalar GetMaxBasisLengthXY() const;
296
297 constexpr Vector3 GetBasisX() const { return Vector3(m[0], m[1], m[2]); }
298
299 constexpr Vector3 GetBasisY() const { return Vector3(m[4], m[5], m[6]); }
300
301 constexpr Vector3 GetBasisZ() const { return Vector3(m[8], m[9], m[10]); }
302
303 constexpr Vector3 GetScale() const {
304 return Vector3(GetBasisX().Length(), GetBasisY().Length(),
305 GetBasisZ().Length());
306 }
307
308 constexpr Scalar GetDirectionScale(Vector3 direction) const {
309 return 1.0f / (this->Basis().Invert() * direction.Normalize()).Length() *
310 direction.Length();
311 }
312
313 constexpr bool IsAffine() const {
314 return (m[2] == 0 && m[3] == 0 && m[6] == 0 && m[7] == 0 && m[8] == 0 &&
315 m[9] == 0 && m[10] == 1 && m[11] == 0 && m[14] == 0 && m[15] == 1);
316 }
317
318 constexpr bool HasPerspective() const {
319 return m[3] != 0 || m[7] != 0 || m[11] != 0 || m[15] != 1;
320 }
321
322 constexpr bool IsAligned(Scalar tolerance = 0) const {
323 int v[] = {!ScalarNearlyZero(m[0], tolerance), //
324 !ScalarNearlyZero(m[1], tolerance), //
325 !ScalarNearlyZero(m[2], tolerance), //
326 !ScalarNearlyZero(m[4], tolerance), //
327 !ScalarNearlyZero(m[5], tolerance), //
328 !ScalarNearlyZero(m[6], tolerance), //
329 !ScalarNearlyZero(m[8], tolerance), //
330 !ScalarNearlyZero(m[9], tolerance), //
331 !ScalarNearlyZero(m[10], tolerance)};
332 // Check if all three basis vectors are aligned to an axis.
333 if (v[0] + v[1] + v[2] != 1 || //
334 v[3] + v[4] + v[5] != 1 || //
335 v[6] + v[7] + v[8] != 1) {
336 return false;
337 }
338 // Ensure that none of the basis vectors overlap.
339 if (v[0] + v[3] + v[6] != 1 || //
340 v[1] + v[4] + v[7] != 1 || //
341 v[2] + v[5] + v[8] != 1) {
342 return false;
343 }
344 return true;
345 }
346
347 constexpr bool IsIdentity() const {
348 return (
349 // clang-format off
350 m[0] == 1.0f && m[1] == 0.0f && m[2] == 0.0f && m[3] == 0.0f &&
351 m[4] == 0.0f && m[5] == 1.0f && m[6] == 0.0f && m[7] == 0.0f &&
352 m[8] == 0.0f && m[9] == 0.0f && m[10] == 1.0f && m[11] == 0.0f &&
353 m[12] == 0.0f && m[13] == 0.0f && m[14] == 0.0f && m[15] == 1.0f
354 // clang-format on
355 );
356 }
357
358 /// @brief Returns true if the matrix has a scale-only basis and is
359 /// non-projective. Note that an identity matrix meets this criteria.
360 constexpr bool IsTranslationScaleOnly() const {
361 return (
362 // clang-format off
363 m[0] != 0.0 && m[1] == 0.0 && m[2] == 0.0 && m[3] == 0.0 &&
364 m[4] == 0.0 && m[5] != 0.0 && m[6] == 0.0 && m[7] == 0.0 &&
365 m[8] == 0.0 && m[9] == 0.0 && m[10] != 0.0 && m[11] == 0.0 &&
366 m[15] == 1.0
367 // clang-format on
368 );
369 }
370
371 std::optional<MatrixDecomposition> Decompose() const;
372
373 constexpr bool operator==(const Matrix& m) const {
374 // clang-format off
375 return vec[0] == m.vec[0]
376 && vec[1] == m.vec[1]
377 && vec[2] == m.vec[2]
378 && vec[3] == m.vec[3];
379 // clang-format on
380 }
381
382 constexpr bool operator!=(const Matrix& m) const {
383 // clang-format off
384 return vec[0] != m.vec[0]
385 || vec[1] != m.vec[1]
386 || vec[2] != m.vec[2]
387 || vec[3] != m.vec[3];
388 // clang-format on
389 }
390
391 Matrix operator+(const Vector3& t) const { return Translate(t); }
392
393 Matrix operator-(const Vector3& t) const { return Translate(-t); }
394
395 Matrix operator*(const Matrix& m) const { return Multiply(m); }
396
397 Matrix operator+(const Matrix& m) const;
398
399 constexpr Vector4 operator*(const Vector4& v) const {
400 return Vector4(v.x * m[0] + v.y * m[4] + v.z * m[8] + v.w * m[12],
401 v.x * m[1] + v.y * m[5] + v.z * m[9] + v.w * m[13],
402 v.x * m[2] + v.y * m[6] + v.z * m[10] + v.w * m[14],
403 v.x * m[3] + v.y * m[7] + v.z * m[11] + v.w * m[15]);
404 }
405
406 constexpr Vector3 operator*(const Vector3& v) const {
407 Scalar w = v.x * m[3] + v.y * m[7] + v.z * m[11] + m[15];
408 Vector3 result(v.x * m[0] + v.y * m[4] + v.z * m[8] + m[12],
409 v.x * m[1] + v.y * m[5] + v.z * m[9] + m[13],
410 v.x * m[2] + v.y * m[6] + v.z * m[10] + m[14]);
411
412 // This is Skia's behavior, but it may be reasonable to allow UB for the w=0
413 // case.
414 if (w) {
415 w = 1 / w;
416 }
417 return result * w;
418 }
419
420 constexpr Point operator*(const Point& v) const {
421 Scalar w = v.x * m[3] + v.y * m[7] + m[15];
422 Point result(v.x * m[0] + v.y * m[4] + m[12],
423 v.x * m[1] + v.y * m[5] + m[13]);
424
425 // This is Skia's behavior, but it may be reasonable to allow UB for the w=0
426 // case.
427 if (w) {
428 w = 1 / w;
429 }
430 return result * w;
431 }
432
433 constexpr Vector4 TransformDirection(const Vector4& v) const {
434 return Vector4(v.x * m[0] + v.y * m[4] + v.z * m[8],
435 v.x * m[1] + v.y * m[5] + v.z * m[9],
436 v.x * m[2] + v.y * m[6] + v.z * m[10], v.w);
437 }
438
439 constexpr Vector3 TransformDirection(const Vector3& v) const {
440 return Vector3(v.x * m[0] + v.y * m[4] + v.z * m[8],
441 v.x * m[1] + v.y * m[5] + v.z * m[9],
442 v.x * m[2] + v.y * m[6] + v.z * m[10]);
443 }
444
445 constexpr Vector2 TransformDirection(const Vector2& v) const {
446 return Vector2(v.x * m[0] + v.y * m[4], v.x * m[1] + v.y * m[5]);
447 }
448
449 constexpr Quad Transform(const Quad& quad) const {
450 return {
451 *this * quad[0],
452 *this * quad[1],
453 *this * quad[2],
454 *this * quad[3],
455 };
456 }
457
458 template <class T>
459 static constexpr Matrix MakeOrthographic(TSize<T> size) {
460 // Per assumptions about NDC documented above.
461 const auto scale =
462 MakeScale({2.0f / static_cast<Scalar>(size.width),
463 -2.0f / static_cast<Scalar>(size.height), 0.0f});
464 const auto translate = MakeTranslation({-1.0f, 1.0f, 0.5f});
465 return translate * scale;
466 }
467
468 static constexpr Matrix MakePerspective(Radians fov_y,
469 Scalar aspect_ratio,
470 Scalar z_near,
471 Scalar z_far) {
472 Scalar height = std::tan(fov_y.radians * 0.5f);
473 Scalar width = height * aspect_ratio;
474
475 // clang-format off
476 return {
477 1.0f / width, 0.0f, 0.0f, 0.0f,
478 0.0f, 1.0f / height, 0.0f, 0.0f,
479 0.0f, 0.0f, z_far / (z_far - z_near), 1.0f,
480 0.0f, 0.0f, -(z_far * z_near) / (z_far - z_near), 0.0f,
481 };
482 // clang-format on
483 }
484
485 template <class T>
486 static constexpr Matrix MakePerspective(Radians fov_y,
487 TSize<T> size,
488 Scalar z_near,
489 Scalar z_far) {
490 return MakePerspective(fov_y, static_cast<Scalar>(size.width) / size.height,
491 z_near, z_far);
492 }
493
494 static constexpr Matrix MakeLookAt(Vector3 position,
495 Vector3 target,
496 Vector3 up) {
497 Vector3 forward = (target - position).Normalize();
498 Vector3 right = up.Cross(forward);
499 up = forward.Cross(right);
500
501 // clang-format off
502 return {
503 right.x, up.x, forward.x, 0.0f,
504 right.y, up.y, forward.y, 0.0f,
505 right.z, up.z, forward.z, 0.0f,
506 -right.Dot(position), -up.Dot(position), -forward.Dot(position), 1.0f
507 };
508 // clang-format on
509 }
510 };
511
512 static_assert(sizeof(struct Matrix) == sizeof(Scalar) * 16,
513 "The matrix must be of consistent size.");
514
515 } // namespace impeller
516
517 namespace std {
518 inline std::ostream& operator<<(std::ostream& out, const impeller::Matrix& m) {
519 out << "(" << std::endl << std::fixed;
520 for (size_t i = 0; i < 4u; i++) {
521 for (size_t j = 0; j < 4u; j++) {
522 out << std::setw(15) << m.e[j][i] << ",";
523 }
524 out << std::endl;
525 }
526 out << ")";
527 return out;
528 }
529
530 } // namespace std
531
532 #endif // FLUTTER_IMPELLER_GEOMETRY_MATRIX_H_
impeller::Matrix::MakeSkew
static constexpr Matrix MakeSkew(Scalar sx, Scalar sy)
Definition: matrix.h:117
impeller::Matrix::HasPerspective
constexpr bool HasPerspective() const
Definition: matrix.h:318
impeller::Matrix::operator+
Matrix operator+(const Vector3 &t) const
Definition: matrix.h:391
impeller::Matrix::m
Scalar m[16]
Definition: matrix.h:39
impeller::Vector3::Dot
constexpr Scalar Dot(const Vector3 &other) const
Definition: vector.h:54
impeller::Matrix::Decompose
std::optional< MatrixDecomposition > Decompose() const
Definition: matrix.cc:217
impeller::Matrix::MakeRotationX
static Matrix MakeRotationX(Radians r)
Definition: matrix.h:182
impeller::Matrix::Matrix
constexpr Matrix()
Definition: matrix.h:47
impeller::Quaternion::z
Scalar z
Definition: quaternion.h:19
point.h
impeller::TPoint::y
Type y
Definition: point.h:26
impeller::Scalar
float Scalar
Definition: scalar.h:18
impeller::Vector3::Cross
constexpr Vector3 Cross(const Vector3 &other) const
Definition: vector.h:62
impeller::Matrix::MakePerspective
static constexpr Matrix MakePerspective(Radians fov_y, TSize< T > size, Scalar z_near, Scalar z_far)
Definition: matrix.h:486
impeller::Vector4::Normalize
Vector4 Normalize() const
Definition: vector.h:258
impeller::Quaternion::w
Scalar w
Definition: quaternion.h:20
impeller::Matrix::operator-
Matrix operator-(const Vector3 &t) const
Definition: matrix.h:393
impeller::Matrix::operator*
constexpr Point operator*(const Point &v) const
Definition: matrix.h:420
impeller::Vector4
Definition: vector.h:232
impeller::Matrix::MakeRotation
static Matrix MakeRotation(Quaternion q)
Definition: matrix.h:126
impeller::Vector2
Point Vector2
Definition: point.h:312
impeller::Matrix::MakeRotationY
static Matrix MakeRotationY(Radians r)
Definition: matrix.h:195
impeller::Matrix::GetDeterminant
Scalar GetDeterminant() const
Definition: matrix.cc:162
quaternion.h
std::operator<<
std::ostream & operator<<(std::ostream &out, const impeller::Color &c)
Definition: color.h:951
impeller::Matrix::operator*
Matrix operator*(const Matrix &m) const
Definition: matrix.h:395
impeller::Radians::radians
Scalar radians
Definition: scalar.h:39
impeller::Matrix::MakeRow
static constexpr Matrix MakeRow(Scalar m0, Scalar m1, Scalar m2, Scalar m3, Scalar m4, Scalar m5, Scalar m6, Scalar m7, Scalar m8, Scalar m9, Scalar m10, Scalar m11, Scalar m12, Scalar m13, Scalar m14, Scalar m15)
Definition: matrix.h:83
impeller::Matrix::MakeTranslation
static constexpr Matrix MakeTranslation(const Vector3 &t)
Definition: matrix.h:95
impeller::Vector3::x
Scalar x
Definition: vector.h:23
impeller::Quaternion::x
Scalar x
Definition: quaternion.h:17
impeller::Matrix::e
Scalar e[4][4]
Definition: matrix.h:40
impeller::Matrix::vec
Vector4 vec[4]
Definition: matrix.h:41
impeller::Matrix::MakeLookAt
static constexpr Matrix MakeLookAt(Vector3 position, Vector3 target, Vector3 up)
Definition: matrix.h:494
impeller::Matrix::MakePerspective
static constexpr Matrix MakePerspective(Radians fov_y, Scalar aspect_ratio, Scalar z_near, Scalar z_far)
Definition: matrix.h:468
impeller::Matrix::Basis
constexpr Matrix Basis() const
The Matrix without its w components (without translation).
Definition: matrix.h:224
impeller::TSize
Definition: size.h:19
impeller::Matrix::TransformDirection
constexpr Vector3 TransformDirection(const Vector3 &v) const
Definition: matrix.h:439
impeller::Quaternion
Definition: quaternion.h:14
impeller::Quad
std::array< Point, 4 > Quad
Definition: point.h:313
impeller::Matrix::Multiply
constexpr Matrix Multiply(const Matrix &o) const
Definition: matrix.h:256
impeller::Matrix::GetScale
constexpr Vector3 GetScale() const
Definition: matrix.h:303
impeller::Matrix::operator==
constexpr bool operator==(const Matrix &m) const
Definition: matrix.h:373
impeller::Matrix::Transpose
constexpr Matrix Transpose() const
Definition: matrix.h:278
impeller::Matrix::GetMaxBasisLength
Scalar GetMaxBasisLength() const
Definition: matrix.cc:196
impeller::Matrix::operator*
constexpr Vector4 operator*(const Vector4 &v) const
Definition: matrix.h:399
impeller::Matrix::IsTranslationScaleOnly
constexpr bool IsTranslationScaleOnly() const
Returns true if the matrix has a scale-only basis and is non-projective. Note that an identity matrix...
Definition: matrix.h:360
impeller::Matrix::Translate
constexpr Matrix Translate(const Vector3 &t) const
Definition: matrix.h:235
impeller::Matrix::Matrix
constexpr Matrix(Scalar m0, Scalar m1, Scalar m2, Scalar m3, Scalar m4, Scalar m5, Scalar m6, Scalar m7, Scalar m8, Scalar m9, Scalar m10, Scalar m11, Scalar m12, Scalar m13, Scalar m14, Scalar m15)
Definition: matrix.h:56
impeller::Matrix::MakeColumn
static constexpr Matrix MakeColumn(Scalar m0, Scalar m1, Scalar m2, Scalar m3, Scalar m4, Scalar m5, Scalar m6, Scalar m7, Scalar m8, Scalar m9, Scalar m10, Scalar m11, Scalar m12, Scalar m13, Scalar m14, Scalar m15)
Definition: matrix.h:69
impeller::Matrix::TransformDirection
constexpr Vector2 TransformDirection(const Vector2 &v) const
Definition: matrix.h:445
impeller::Vector3::z
Scalar z
Definition: vector.h:25
impeller::Matrix::IsAffine
constexpr bool IsAffine() const
Definition: matrix.h:313
impeller::Radians
Definition: scalar.h:38
impeller::ScalarNearlyZero
constexpr bool ScalarNearlyZero(Scalar x, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:25
impeller::Vector3::Length
constexpr Scalar Length() const
Definition: vector.h:47
impeller::Vector4::x
Scalar x
Definition: vector.h:235
impeller::Vector3::y
Scalar y
Definition: vector.h:24
impeller::Matrix::GetBasisZ
constexpr Vector3 GetBasisZ() const
Definition: matrix.h:301
impeller::TSize::width
Type width
Definition: size.h:22
impeller::Matrix::Transform
constexpr Quad Transform(const Quad &quad) const
Definition: matrix.h:449
impeller::Matrix::Invert
Matrix Invert() const
Definition: matrix.cc:97
impeller::TPoint::x
Type x
Definition: point.h:25
impeller::Matrix::IsIdentity
constexpr bool IsIdentity() const
Definition: matrix.h:347
impeller::Matrix::GetDirectionScale
constexpr Scalar GetDirectionScale(Vector3 direction) const
Definition: matrix.h:308
scalar.h
impeller::Vector3::Normalize
constexpr Vector3 Normalize() const
Definition: vector.h:49
impeller::Matrix::TransformDirection
constexpr Vector4 TransformDirection(const Vector4 &v) const
Definition: matrix.h:433
impeller::Vector4::w
Scalar w
Definition: vector.h:238
impeller::Matrix::MakeRotationZ
static Matrix MakeRotationZ(Radians r)
Definition: matrix.h:209
vector.h
std
Definition: comparable.h:95
impeller::Vector4::y
Scalar y
Definition: vector.h:236
impeller::Matrix::MakeRotation
static Matrix MakeRotation(Scalar radians, const Vector4 &r)
Definition: matrix.h:151
shear.h
impeller::TPoint< Scalar >
impeller::Matrix::operator*
constexpr Vector3 operator*(const Vector3 &v) const
Definition: matrix.h:406
impeller::Matrix::operator!=
constexpr bool operator!=(const Matrix &m) const
Definition: matrix.h:382
impeller::Quaternion::y
Scalar y
Definition: quaternion.h:18
impeller::Matrix::MakeOrthographic
static constexpr Matrix MakeOrthographic(TSize< T > size)
Definition: matrix.h:459
matrix_decomposition.h
impeller::TSize::height
Type height
Definition: size.h:23
impeller::Matrix::GetBasisY
constexpr Vector3 GetBasisY() const
Definition: matrix.h:299
impeller::Vector4::z
Scalar z
Definition: vector.h:237
impeller
Definition: aiks_context.cc:10
impeller::Matrix::MakeScale
static constexpr Matrix MakeScale(const Vector3 &s)
Definition: matrix.h:104
impeller::Matrix::MakeScale
static constexpr Matrix MakeScale(const Vector2 &s)
Definition: matrix.h:113
impeller::Matrix::GetBasisX
constexpr Vector3 GetBasisX() const
Definition: matrix.h:297
impeller::Matrix
A 4x4 matrix using column-major storage.
Definition: matrix.h:37
impeller::Vector3
Definition: vector.h:20
size.h
impeller::Matrix::GetMaxBasisLengthXY
Scalar GetMaxBasisLengthXY() const
Definition: matrix.cc:205
impeller::Matrix::Scale
constexpr Matrix Scale(const Vector3 &s) const
Definition: matrix.h:247
impeller::Matrix::IsAligned
constexpr bool IsAligned(Scalar tolerance=0) const
Definition: matrix.h:322