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