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