Flutter Impeller
impeller::Matrix Struct Reference

A 4x4 matrix using column-major storage. More...

#include <matrix.h>

Public Member Functions

constexpr 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)
 
 Matrix (const MatrixDecomposition &decomposition)
 
constexpr Matrix Basis () const
 The Matrix without its w components (without translation). More...
 
constexpr Matrix Translate (const Vector3 &t) const
 
constexpr Matrix Scale (const Vector3 &s) const
 
constexpr Matrix Multiply (const Matrix &o) const
 
constexpr Matrix Transpose () const
 
Matrix Invert () const
 
Scalar GetDeterminant () const
 
Scalar GetMaxBasisLength () const
 
constexpr Scalar GetMaxBasisLengthXY () const
 
constexpr Vector3 GetBasisX () const
 
constexpr Vector3 GetBasisY () const
 
constexpr Vector3 GetBasisZ () const
 
constexpr Vector3 GetScale () const
 
constexpr Scalar GetDirectionScale (Vector3 direction) const
 
constexpr bool IsAffine () const
 
constexpr bool HasPerspective () const
 
constexpr bool IsAligned (Scalar tolerance=0) const
 
constexpr bool IsIdentity () const
 
constexpr bool IsTranslationScaleOnly () const
 Returns true if the matrix has a scale-only basis and is non-projective. Note that an identity matrix meets this criteria. More...
 
std::optional< MatrixDecompositionDecompose () const
 
constexpr bool operator== (const Matrix &m) const
 
constexpr bool operator!= (const Matrix &m) const
 
Matrix operator+ (const Vector3 &t) const
 
Matrix operator- (const Vector3 &t) const
 
Matrix operator* (const Matrix &m) const
 
Matrix operator+ (const Matrix &m) const
 
constexpr Vector4 operator* (const Vector4 &v) const
 
constexpr Vector3 operator* (const Vector3 &v) const
 
constexpr Point operator* (const Point &v) const
 
constexpr Vector4 TransformDirection (const Vector4 &v) const
 
constexpr Vector3 TransformDirection (const Vector3 &v) const
 
constexpr Vector2 TransformDirection (const Vector2 &v) const
 
constexpr Quad Transform (const Quad &quad) const
 

Static Public Member Functions

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)
 
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)
 
static constexpr Matrix MakeTranslation (const Vector3 &t)
 
static constexpr Matrix MakeScale (const Vector3 &s)
 
static constexpr Matrix MakeScale (const Vector2 &s)
 
static constexpr Matrix MakeSkew (Scalar sx, Scalar sy)
 
static Matrix MakeRotation (Quaternion q)
 
static Matrix MakeRotation (Scalar radians, const Vector4 &r)
 
static Matrix MakeRotationX (Radians r)
 
static Matrix MakeRotationY (Radians r)
 
static Matrix MakeRotationZ (Radians r)
 
template<class T >
static constexpr Matrix MakeOrthographic (TSize< T > size)
 
static constexpr Matrix MakePerspective (Radians fov_y, Scalar aspect_ratio, Scalar z_near, Scalar z_far)
 
template<class T >
static constexpr Matrix MakePerspective (Radians fov_y, TSize< T > size, Scalar z_near, Scalar z_far)
 
static constexpr Matrix MakeLookAt (Vector3 position, Vector3 target, Vector3 up)
 

Public Attributes

union {
   Scalar   m [16]
 
   Scalar   e [4][4]
 
   Vector4   vec [4]
 
}; 
 

Detailed Description

A 4x4 matrix using column-major storage.

        Utility methods that need to make assumptions about normalized
        device coordinates must use the following convention:
          * Left-handed coordinate system. Positive rotation is
            clockwise about axis of rotation.
          * Lower left corner is -1.0f, -1.0.
          * Upper right corner is  1.0f,  1.0.
          * Visible z-space is from 0.0 to 1.0.
            * This is NOT the same as OpenGL! Be careful.
          * NDC origin is at (0.0f, 0.0f, 0.5f). 

Definition at line 37 of file matrix.h.

Constructor & Destructor Documentation

◆ Matrix() [1/3]

constexpr impeller::Matrix::Matrix ( )
inlineconstexpr

Constructs a default identity matrix.

Definition at line 47 of file matrix.h.

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)} {}

Referenced by Basis(), MakeColumn(), MakeRotation(), MakeRotationX(), MakeRotationY(), MakeRotationZ(), MakeRow(), MakeScale(), MakeSkew(), MakeTranslation(), Multiply(), operator+(), Scale(), and Translate().

◆ Matrix() [2/3]

constexpr impeller::Matrix::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 
)
inlineconstexpr

Definition at line 56 of file matrix.h.

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)} {}

◆ Matrix() [3/3]

impeller::Matrix::Matrix ( const MatrixDecomposition decomposition)
explicit

Definition at line 12 of file matrix.cc.

12  : Matrix() {
13  /*
14  * Apply perspective.
15  */
16  for (int i = 0; i < 4; i++) {
17  e[i][3] = d.perspective.e[i];
18  }
19 
20  /*
21  * Apply translation.
22  */
23  for (int i = 0; i < 3; i++) {
24  for (int j = 0; j < 3; j++) {
25  e[3][i] += d.translation.e[j] * e[j][i];
26  }
27  }
28 
29  /*
30  * Apply rotation.
31  */
32 
33  Matrix rotation;
34 
35  const auto x = -d.rotation.x;
36  const auto y = -d.rotation.y;
37  const auto z = -d.rotation.z;
38  const auto w = d.rotation.w;
39 
40  /*
41  * Construct a composite rotation matrix from the quaternion values.
42  */
43 
44  rotation.e[0][0] = 1.0 - 2.0 * (y * y + z * z);
45  rotation.e[0][1] = 2.0 * (x * y - z * w);
46  rotation.e[0][2] = 2.0 * (x * z + y * w);
47  rotation.e[1][0] = 2.0 * (x * y + z * w);
48  rotation.e[1][1] = 1.0 - 2.0 * (x * x + z * z);
49  rotation.e[1][2] = 2.0 * (y * z - x * w);
50  rotation.e[2][0] = 2.0 * (x * z - y * w);
51  rotation.e[2][1] = 2.0 * (y * z + x * w);
52  rotation.e[2][2] = 1.0 - 2.0 * (x * x + y * y);
53 
54  *this = *this * rotation;
55 
56  /*
57  * Apply shear.
58  */
59  Matrix shear;
60 
61  if (d.shear.e[2] != 0) {
62  shear.e[2][1] = d.shear.e[2];
63  *this = *this * shear;
64  }
65 
66  if (d.shear.e[1] != 0) {
67  shear.e[2][1] = 0.0;
68  shear.e[2][0] = d.shear.e[1];
69  *this = *this * shear;
70  }
71 
72  if (d.shear.e[0] != 0) {
73  shear.e[2][0] = 0.0;
74  shear.e[1][0] = d.shear.e[0];
75  *this = *this * shear;
76  }
77 
78  /*
79  * Apply scale.
80  */
81  for (int i = 0; i < 3; i++) {
82  for (int j = 0; j < 3; j++) {
83  e[i][j] *= d.scale.e[i];
84  }
85  }
86 }

References impeller::Shear::e, impeller::Vector3::e, e, impeller::Vector4::e, impeller::MatrixDecomposition::perspective, impeller::MatrixDecomposition::rotation, impeller::MatrixDecomposition::scale, impeller::MatrixDecomposition::shear, impeller::MatrixDecomposition::translation, impeller::Quaternion::w, impeller::Quaternion::x, impeller::Quaternion::y, and impeller::Quaternion::z.

Member Function Documentation

◆ Basis()

constexpr Matrix impeller::Matrix::Basis ( ) const
inlineconstexpr

The Matrix without its w components (without translation).

Definition at line 224 of file matrix.h.

224  {
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  }

References m, and Matrix().

Referenced by GetDirectionScale(), impeller::DirectionalMorphologyFilterContents::GetFilterCoverage(), impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::LocalMatrixFilterContents::GetFilterSourceCoverage(), impeller::GaussianBlurFilterContents::GetFilterSourceCoverage(), impeller::MatrixFilterContents::IsTranslationOnly(), and impeller::testing::TEST().

◆ Decompose()

std::optional< MatrixDecomposition > impeller::Matrix::Decompose ( ) const

Definition at line 209 of file matrix.cc.

209  {
210  /*
211  * Normalize the matrix.
212  */
213  Matrix self = *this;
214 
215  if (self.e[3][3] == 0) {
216  return std::nullopt;
217  }
218 
219  for (int i = 0; i < 4; i++) {
220  for (int j = 0; j < 4; j++) {
221  self.e[i][j] /= self.e[3][3];
222  }
223  }
224 
225  /*
226  * `perspectiveMatrix` is used to solve for perspective, but it also provides
227  * an easy way to test for singularity of the upper 3x3 component.
228  */
229  Matrix perpectiveMatrix = self;
230  for (int i = 0; i < 3; i++) {
231  perpectiveMatrix.e[i][3] = 0;
232  }
233 
234  perpectiveMatrix.e[3][3] = 1;
235 
236  if (perpectiveMatrix.GetDeterminant() == 0.0) {
237  return std::nullopt;
238  }
239 
240  MatrixDecomposition result;
241 
242  /*
243  * ==========================================================================
244  * First, isolate perspective.
245  * ==========================================================================
246  */
247  if (self.e[0][3] != 0.0 || self.e[1][3] != 0.0 || self.e[2][3] != 0.0) {
248  /*
249  * prhs is the right hand side of the equation.
250  */
251  const Vector4 rightHandSide(self.e[0][3], //
252  self.e[1][3], //
253  self.e[2][3], //
254  self.e[3][3]);
255 
256  /*
257  * Solve the equation by inverting `perspectiveMatrix` and multiplying
258  * prhs by the inverse.
259  */
260 
261  result.perspective = perpectiveMatrix.Invert().Transpose() * rightHandSide;
262 
263  /*
264  * Clear the perspective partition.
265  */
266  self.e[0][3] = self.e[1][3] = self.e[2][3] = 0;
267  self.e[3][3] = 1;
268  }
269 
270  /*
271  * ==========================================================================
272  * Next, the translation.
273  * ==========================================================================
274  */
275  result.translation = {self.e[3][0], self.e[3][1], self.e[3][2]};
276  self.e[3][0] = self.e[3][1] = self.e[3][2] = 0.0;
277 
278  /*
279  * ==========================================================================
280  * Next, the scale and shear.
281  * ==========================================================================
282  */
283  Vector3 row[3];
284  for (int i = 0; i < 3; i++) {
285  row[i].x = self.e[i][0];
286  row[i].y = self.e[i][1];
287  row[i].z = self.e[i][2];
288  }
289 
290  /*
291  * Compute X scale factor and normalize first row.
292  */
293  result.scale.x = row[0].Length();
294  row[0] = row[0].Normalize();
295 
296  /*
297  * Compute XY shear factor and make 2nd row orthogonal to 1st.
298  */
299  result.shear.xy = row[0].Dot(row[1]);
300  row[1] = Vector3::Combine(row[1], 1.0, row[0], -result.shear.xy);
301 
302  /*
303  * Compute Y scale and normalize 2nd row.
304  */
305  result.scale.y = row[1].Length();
306  row[1] = row[1].Normalize();
307  result.shear.xy /= result.scale.y;
308 
309  /*
310  * Compute XZ and YZ shears, orthogonalize 3rd row.
311  */
312  result.shear.xz = row[0].Dot(row[2]);
313  row[2] = Vector3::Combine(row[2], 1.0, row[0], -result.shear.xz);
314  result.shear.yz = row[1].Dot(row[2]);
315  row[2] = Vector3::Combine(row[2], 1.0, row[1], -result.shear.yz);
316 
317  /*
318  * Next, get Z scale and normalize 3rd row.
319  */
320  result.scale.z = row[2].Length();
321  row[2] = row[2].Normalize();
322 
323  result.shear.xz /= result.scale.z;
324  result.shear.yz /= result.scale.z;
325 
326  /*
327  * At this point, the matrix (in rows[]) is orthonormal.
328  * Check for a coordinate system flip. If the determinant
329  * is -1, then negate the matrix and the scaling factors.
330  */
331  if (row[0].Dot(row[1].Cross(row[2])) < 0) {
332  result.scale.x *= -1;
333  result.scale.y *= -1;
334  result.scale.z *= -1;
335 
336  for (int i = 0; i < 3; i++) {
337  row[i].x *= -1;
338  row[i].y *= -1;
339  row[i].z *= -1;
340  }
341  }
342 
343  /*
344  * ==========================================================================
345  * Finally, get the rotations out.
346  * ==========================================================================
347  */
348  result.rotation.x =
349  0.5 * sqrt(fmax(1.0 + row[0].x - row[1].y - row[2].z, 0.0));
350  result.rotation.y =
351  0.5 * sqrt(fmax(1.0 - row[0].x + row[1].y - row[2].z, 0.0));
352  result.rotation.z =
353  0.5 * sqrt(fmax(1.0 - row[0].x - row[1].y + row[2].z, 0.0));
354  result.rotation.w =
355  0.5 * sqrt(fmax(1.0 + row[0].x + row[1].y + row[2].z, 0.0));
356 
357  if (row[2].y > row[1].z) {
358  result.rotation.x = -result.rotation.x;
359  }
360  if (row[0].z > row[2].x) {
361  result.rotation.y = -result.rotation.y;
362  }
363  if (row[1].x > row[0].y) {
364  result.rotation.z = -result.rotation.z;
365  }
366 
367  return result;
368 }

References impeller::Vector3::Combine(), impeller::Vector3::Dot(), impeller::Vector3::e, e, impeller::Vector4::e, GetDeterminant(), Invert(), impeller::Vector3::Length(), impeller::Vector3::Normalize(), impeller::MatrixDecomposition::perspective, impeller::MatrixDecomposition::rotation, impeller::MatrixDecomposition::scale, impeller::MatrixDecomposition::shear, impeller::MatrixDecomposition::translation, Transpose(), impeller::Quaternion::w, impeller::Quaternion::x, impeller::Vector3::x, impeller::Shear::xy, impeller::Shear::xz, impeller::Quaternion::y, impeller::Vector3::y, impeller::Shear::yz, impeller::Quaternion::z, and impeller::Vector3::z.

Referenced by impeller::testing::TEST().

◆ GetBasisX()

constexpr Vector3 impeller::Matrix::GetBasisX ( ) const
inlineconstexpr

Definition at line 300 of file matrix.h.

300 { return Vector3(m[0], m[1], m[2]); }

References m.

Referenced by GetScale().

◆ GetBasisY()

constexpr Vector3 impeller::Matrix::GetBasisY ( ) const
inlineconstexpr

Definition at line 302 of file matrix.h.

302 { return Vector3(m[4], m[5], m[6]); }

References m.

Referenced by GetScale().

◆ GetBasisZ()

constexpr Vector3 impeller::Matrix::GetBasisZ ( ) const
inlineconstexpr

Definition at line 304 of file matrix.h.

304 { return Vector3(m[8], m[9], m[10]); }

References m.

Referenced by GetScale().

◆ GetDeterminant()

Scalar impeller::Matrix::GetDeterminant ( ) const

Definition at line 162 of file matrix.cc.

162  {
163  auto a00 = e[0][0];
164  auto a01 = e[0][1];
165  auto a02 = e[0][2];
166  auto a03 = e[0][3];
167  auto a10 = e[1][0];
168  auto a11 = e[1][1];
169  auto a12 = e[1][2];
170  auto a13 = e[1][3];
171  auto a20 = e[2][0];
172  auto a21 = e[2][1];
173  auto a22 = e[2][2];
174  auto a23 = e[2][3];
175  auto a30 = e[3][0];
176  auto a31 = e[3][1];
177  auto a32 = e[3][2];
178  auto a33 = e[3][3];
179 
180  auto b00 = a00 * a11 - a01 * a10;
181  auto b01 = a00 * a12 - a02 * a10;
182  auto b02 = a00 * a13 - a03 * a10;
183  auto b03 = a01 * a12 - a02 * a11;
184  auto b04 = a01 * a13 - a03 * a11;
185  auto b05 = a02 * a13 - a03 * a12;
186  auto b06 = a20 * a31 - a21 * a30;
187  auto b07 = a20 * a32 - a22 * a30;
188  auto b08 = a20 * a33 - a23 * a30;
189  auto b09 = a21 * a32 - a22 * a31;
190  auto b10 = a21 * a33 - a23 * a31;
191  auto b11 = a22 * a33 - a23 * a32;
192 
193  return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
194 }

References e.

Referenced by impeller::LineGeometry::ComputePixelHalfWidth(), and Decompose().

◆ GetDirectionScale()

constexpr Scalar impeller::Matrix::GetDirectionScale ( Vector3  direction) const
inlineconstexpr

Definition at line 311 of file matrix.h.

311  {
312  return 1.0f / (this->Basis().Invert() * direction.Normalize()).Length() *
313  direction.Length();
314  }

References Basis(), Invert(), impeller::Vector3::Length(), and impeller::Vector3::Normalize().

Referenced by impeller::testing::TEST().

◆ GetMaxBasisLength()

Scalar impeller::Matrix::GetMaxBasisLength ( ) const

Definition at line 196 of file matrix.cc.

196  {
197  Scalar max = 0;
198  for (int i = 0; i < 3; i++) {
199  max = std::max(max,
200  e[i][0] * e[i][0] + e[i][1] * e[i][1] + e[i][2] * e[i][2]);
201  }
202  return std::sqrt(max);
203 }

References e.

Referenced by impeller::Tessellator::FilledCircle(), impeller::Tessellator::FilledEllipse(), impeller::Tessellator::FilledRoundRect(), impeller::Tessellator::RoundCapLine(), and impeller::Tessellator::StrokedCircle().

◆ GetMaxBasisLengthXY()

constexpr Scalar impeller::Matrix::GetMaxBasisLengthXY ( ) const
inlineconstexpr

Definition at line 295 of file matrix.h.

295  {
296  return std::sqrt(std::max(e[0][0] * e[0][0] + e[0][1] * e[0][1],
297  e[1][0] * e[1][0] + e[1][1] * e[1][1]));
298  }

References e.

Referenced by impeller::Entity::DeriveTextScale().

◆ GetScale()

constexpr Vector3 impeller::Matrix::GetScale ( ) const
inlineconstexpr

Definition at line 306 of file matrix.h.

306  {
307  return Vector3(GetBasisX().Length(), GetBasisY().Length(),
308  GetBasisZ().Length());
309  }

References GetBasisX(), GetBasisY(), and GetBasisZ().

Referenced by impeller::DlDispatcher::drawShadow(), impeller::SceneContents::Render(), and impeller::testing::TEST_P().

◆ HasPerspective()

constexpr bool impeller::Matrix::HasPerspective ( ) const
inlineconstexpr

Definition at line 321 of file matrix.h.

321  {
322  return m[3] != 0 || m[7] != 0 || m[11] != 0 || m[15] != 1;
323  }

References m.

Referenced by impeller::DlDispatcher::drawDisplayList().

◆ Invert()

Matrix impeller::Matrix::Invert ( ) const

Definition at line 97 of file matrix.cc.

97  {
98  Matrix tmp{
99  m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] +
100  m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10],
101 
102  -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15] -
103  m[9] * m[3] * m[14] - m[13] * m[2] * m[11] + m[13] * m[3] * m[10],
104 
105  m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] +
106  m[5] * m[3] * m[14] + m[13] * m[2] * m[7] - m[13] * m[3] * m[6],
107 
108  -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] -
109  m[5] * m[3] * m[10] - m[9] * m[2] * m[7] + m[9] * m[3] * m[6],
110 
111  -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15] -
112  m[8] * m[7] * m[14] - m[12] * m[6] * m[11] + m[12] * m[7] * m[10],
113 
114  m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] +
115  m[8] * m[3] * m[14] + m[12] * m[2] * m[11] - m[12] * m[3] * m[10],
116 
117  -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] -
118  m[4] * m[3] * m[14] - m[12] * m[2] * m[7] + m[12] * m[3] * m[6],
119 
120  m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] +
121  m[4] * m[3] * m[10] + m[8] * m[2] * m[7] - m[8] * m[3] * m[6],
122 
123  m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] +
124  m[8] * m[7] * m[13] + m[12] * m[5] * m[11] - m[12] * m[7] * m[9],
125 
126  -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] -
127  m[8] * m[3] * m[13] - m[12] * m[1] * m[11] + m[12] * m[3] * m[9],
128 
129  m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] +
130  m[4] * m[3] * m[13] + m[12] * m[1] * m[7] - m[12] * m[3] * m[5],
131 
132  -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] -
133  m[4] * m[3] * m[9] - m[8] * m[1] * m[7] + m[8] * m[3] * m[5],
134 
135  -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14] -
136  m[8] * m[6] * m[13] - m[12] * m[5] * m[10] + m[12] * m[6] * m[9],
137 
138  m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] +
139  m[8] * m[2] * m[13] + m[12] * m[1] * m[10] - m[12] * m[2] * m[9],
140 
141  -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] -
142  m[4] * m[2] * m[13] - m[12] * m[1] * m[6] + m[12] * m[2] * m[5],
143 
144  m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] +
145  m[4] * m[2] * m[9] + m[8] * m[1] * m[6] - m[8] * m[2] * m[5]};
146 
147  Scalar det =
148  m[0] * tmp.m[0] + m[1] * tmp.m[4] + m[2] * tmp.m[8] + m[3] * tmp.m[12];
149 
150  if (det == 0) {
151  return {};
152  }
153 
154  det = 1.0 / det;
155 
156  return {tmp.m[0] * det, tmp.m[1] * det, tmp.m[2] * det, tmp.m[3] * det,
157  tmp.m[4] * det, tmp.m[5] * det, tmp.m[6] * det, tmp.m[7] * det,
158  tmp.m[8] * det, tmp.m[9] * det, tmp.m[10] * det, tmp.m[11] * det,
159  tmp.m[12] * det, tmp.m[13] * det, tmp.m[14] * det, tmp.m[15] * det};
160 }

References m.

Referenced by Decompose(), GetDirectionScale(), impeller::MatrixFilterContents::GetFilterCoverage(), impeller::LocalMatrixFilterContents::GetFilterSourceCoverage(), impeller::Snapshot::GetUVTransform(), impeller::scene::Skin::MakeFromFlatbuffer(), impeller::ColorSourceContents::SetEffectTransform(), impeller::scene::Node::SetGlobalTransform(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ IsAffine()

constexpr bool impeller::Matrix::IsAffine ( ) const
inlineconstexpr

Definition at line 316 of file matrix.h.

316  {
317  return (m[2] == 0 && m[3] == 0 && m[6] == 0 && m[7] == 0 && m[8] == 0 &&
318  m[9] == 0 && m[10] == 1 && m[11] == 0 && m[14] == 0 && m[15] == 1);
319  }

References m.

◆ IsAligned()

constexpr bool impeller::Matrix::IsAligned ( Scalar  tolerance = 0) const
inlineconstexpr

Definition at line 325 of file matrix.h.

325  {
326  int v[] = {!ScalarNearlyZero(m[0], tolerance), //
327  !ScalarNearlyZero(m[1], tolerance), //
328  !ScalarNearlyZero(m[2], tolerance), //
329  !ScalarNearlyZero(m[4], tolerance), //
330  !ScalarNearlyZero(m[5], tolerance), //
331  !ScalarNearlyZero(m[6], tolerance), //
332  !ScalarNearlyZero(m[8], tolerance), //
333  !ScalarNearlyZero(m[9], tolerance), //
334  !ScalarNearlyZero(m[10], tolerance)};
335  // Check if all three basis vectors are aligned to an axis.
336  if (v[0] + v[1] + v[2] != 1 || //
337  v[3] + v[4] + v[5] != 1 || //
338  v[6] + v[7] + v[8] != 1) {
339  return false;
340  }
341  // Ensure that none of the basis vectors overlap.
342  if (v[0] + v[3] + v[6] != 1 || //
343  v[1] + v[4] + v[7] != 1 || //
344  v[2] + v[5] + v[8] != 1) {
345  return false;
346  }
347  return true;
348  }

References m, and impeller::ScalarNearlyZero().

Referenced by impeller::testing::TEST().

◆ IsIdentity()

constexpr bool impeller::Matrix::IsIdentity ( ) const
inlineconstexpr

Definition at line 350 of file matrix.h.

350  {
351  return (
352  // clang-format off
353  m[0] == 1.0f && m[1] == 0.0f && m[2] == 0.0f && m[3] == 0.0f &&
354  m[4] == 0.0f && m[5] == 1.0f && m[6] == 0.0f && m[7] == 0.0f &&
355  m[8] == 0.0f && m[9] == 0.0f && m[10] == 1.0f && m[11] == 0.0f &&
356  m[12] == 0.0f && m[13] == 0.0f && m[14] == 0.0f && m[15] == 1.0f
357  // clang-format on
358  );
359  }

References m.

Referenced by impeller::MatrixFilterContents::IsTranslationOnly(), impeller::scene::importer::ProcessNode(), and impeller::testing::TEST_P().

◆ IsTranslationScaleOnly()

constexpr bool impeller::Matrix::IsTranslationScaleOnly ( ) const
inlineconstexpr

Returns true if the matrix has a scale-only basis and is non-projective. Note that an identity matrix meets this criteria.

Definition at line 363 of file matrix.h.

363  {
364  return (
365  // clang-format off
366  m[0] != 0.0 && m[1] == 0.0 && m[2] == 0.0 && m[3] == 0.0 &&
367  m[4] == 0.0 && m[5] != 0.0 && m[6] == 0.0 && m[7] == 0.0 &&
368  m[8] == 0.0 && m[9] == 0.0 && m[10] != 0.0 && m[11] == 0.0 &&
369  m[15] == 1.0
370  // clang-format on
371  );
372  }

References m.

Referenced by impeller::RectGeometry::CoversArea(), impeller::LineGeometry::CoversArea(), impeller::RoundRectGeometry::CoversArea(), impeller::FillPathGeometry::CoversArea(), and impeller::TextContents::Render().

◆ MakeColumn()

static constexpr Matrix impeller::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 
)
inlinestaticconstexpr

Definition at line 69 of file matrix.h.

73  {
74  return Matrix(m0, m1, m2, m3,
75  m4, m5, m6, m7,
76  m8, m9, m10, m11,
77  m12, m13, m14, m15);
78 
79  }

References Matrix().

Referenced by impeller::testing::TEST().

◆ MakeLookAt()

static constexpr Matrix impeller::Matrix::MakeLookAt ( Vector3  position,
Vector3  target,
Vector3  up 
)
inlinestaticconstexpr

Definition at line 497 of file matrix.h.

499  {
500  Vector3 forward = (target - position).Normalize();
501  Vector3 right = up.Cross(forward);
502  up = forward.Cross(right);
503 
504  // clang-format off
505  return {
506  right.x, up.x, forward.x, 0.0f,
507  right.y, up.y, forward.y, 0.0f,
508  right.z, up.z, forward.z, 0.0f,
509  -right.Dot(position), -up.Dot(position), -forward.Dot(position), 1.0f
510  };
511  // clang-format on
512  }

References impeller::Vector3::Cross(), impeller::Vector3::Dot(), impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

Referenced by impeller::scene::Camera::GetTransform(), and impeller::testing::TEST().

◆ MakeOrthographic()

template<class T >
static constexpr Matrix impeller::Matrix::MakeOrthographic ( TSize< T >  size)
inlinestaticconstexpr

Definition at line 462 of file matrix.h.

462  {
463  // Per assumptions about NDC documented above.
464  const auto scale =
465  MakeScale({2.0f / static_cast<Scalar>(size.width),
466  -2.0f / static_cast<Scalar>(size.height), 0.0f});
467  const auto translate = MakeTranslation({-1.0f, 1.0f, 0.5f});
468  return translate * scale;
469  }

References impeller::TSize< T >::height, MakeScale(), MakeTranslation(), scale, and impeller::TSize< T >::width.

Referenced by ImGui_ImplImpeller_RenderDrawData(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ MakePerspective() [1/2]

static constexpr Matrix impeller::Matrix::MakePerspective ( Radians  fov_y,
Scalar  aspect_ratio,
Scalar  z_near,
Scalar  z_far 
)
inlinestaticconstexpr

Definition at line 471 of file matrix.h.

474  {
475  Scalar height = std::tan(fov_y.radians * 0.5f);
476  Scalar width = height * aspect_ratio;
477 
478  // clang-format off
479  return {
480  1.0f / width, 0.0f, 0.0f, 0.0f,
481  0.0f, 1.0f / height, 0.0f, 0.0f,
482  0.0f, 0.0f, z_far / (z_far - z_near), 1.0f,
483  0.0f, 0.0f, -(z_far * z_near) / (z_far - z_near), 0.0f,
484  };
485  // clang-format on
486  }

References impeller::Radians::radians.

Referenced by impeller::scene::Camera::GetTransform(), MakePerspective(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ MakePerspective() [2/2]

template<class T >
static constexpr Matrix impeller::Matrix::MakePerspective ( Radians  fov_y,
TSize< T >  size,
Scalar  z_near,
Scalar  z_far 
)
inlinestaticconstexpr

Definition at line 489 of file matrix.h.

492  {
493  return MakePerspective(fov_y, static_cast<Scalar>(size.width) / size.height,
494  z_near, z_far);
495  }

References impeller::TSize< T >::height, MakePerspective(), and impeller::TSize< T >::width.

◆ MakeRotation() [1/2]

static Matrix impeller::Matrix::MakeRotation ( Quaternion  q)
inlinestatic

Definition at line 126 of file matrix.h.

126  {
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  }

References Matrix(), impeller::Quaternion::w, impeller::Quaternion::x, impeller::Quaternion::y, and impeller::Quaternion::z.

Referenced by impeller::scene::importer::ProcessNode(), impeller::testing::TEST(), and impeller::scene::testing::TEST_P().

◆ MakeRotation() [2/2]

static Matrix impeller::Matrix::MakeRotation ( Scalar  radians,
const Vector4 r 
)
inlinestatic

Definition at line 151 of file matrix.h.

151  {
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  }

References Matrix(), impeller::Vector4::Normalize(), impeller::Vector4::x, impeller::Vector4::y, and impeller::Vector4::z.

◆ MakeRotationX()

static Matrix impeller::Matrix::MakeRotationX ( Radians  r)
inlinestatic

Definition at line 182 of file matrix.h.

182  {
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  }

References Matrix(), and impeller::Radians::radians.

Referenced by impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ MakeRotationY()

static Matrix impeller::Matrix::MakeRotationY ( Radians  r)
inlinestatic

Definition at line 195 of file matrix.h.

195  {
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  }

References Matrix(), and impeller::Radians::radians.

Referenced by impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ MakeRotationZ()

static Matrix impeller::Matrix::MakeRotationZ ( Radians  r)
inlinestatic

Definition at line 209 of file matrix.h.

209  {
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  }

References Matrix(), and impeller::Radians::radians.

Referenced by impeller::Canvas::Rotate(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ MakeRow()

static constexpr Matrix impeller::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 
)
inlinestaticconstexpr

Definition at line 83 of file matrix.h.

87  {
88  return Matrix(m0, m4, m8, m12,
89  m1, m5, m9, m13,
90  m2, m6, m10, m14,
91  m3, m7, m11, m15);
92  }

References Matrix().

Referenced by impeller::testing::TEST().

◆ MakeScale() [1/2]

static constexpr Matrix impeller::Matrix::MakeScale ( const Vector2 s)
inlinestaticconstexpr

Definition at line 113 of file matrix.h.

113  {
114  return MakeScale(Vector3(s.x, s.y, 1.0f));
115  }

References MakeScale(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ MakeScale() [2/2]

◆ MakeSkew()

static constexpr Matrix impeller::Matrix::MakeSkew ( Scalar  sx,
Scalar  sy 
)
inlinestaticconstexpr

Definition at line 117 of file matrix.h.

117  {
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  }

References Matrix().

Referenced by impeller::Canvas::Skew(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ MakeTranslation()

◆ Multiply()

constexpr Matrix impeller::Matrix::Multiply ( const Matrix o) const
inlineconstexpr

Definition at line 256 of file matrix.h.

256  {
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  }

References m, and Matrix().

Referenced by operator*().

◆ operator!=()

constexpr bool impeller::Matrix::operator!= ( const Matrix m) const
inlineconstexpr

Definition at line 385 of file matrix.h.

385  {
386  // clang-format off
387  return vec[0] != m.vec[0]
388  || vec[1] != m.vec[1]
389  || vec[2] != m.vec[2]
390  || vec[3] != m.vec[3];
391  // clang-format on
392  }

References m, and vec.

◆ operator*() [1/4]

Matrix impeller::Matrix::operator* ( const Matrix m) const
inline

Definition at line 398 of file matrix.h.

398 { return Multiply(m); }

References m, and Multiply().

◆ operator*() [2/4]

constexpr Point impeller::Matrix::operator* ( const Point v) const
inlineconstexpr

Definition at line 423 of file matrix.h.

423  {
424  Scalar w = v.x * m[3] + v.y * m[7] + m[15];
425  Point result(v.x * m[0] + v.y * m[4] + m[12],
426  v.x * m[1] + v.y * m[5] + m[13]);
427 
428  // This is Skia's behavior, but it may be reasonable to allow UB for the w=0
429  // case.
430  if (w) {
431  w = 1 / w;
432  }
433  return result * w;
434  }

References m, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ operator*() [3/4]

constexpr Vector3 impeller::Matrix::operator* ( const Vector3 v) const
inlineconstexpr

Definition at line 409 of file matrix.h.

409  {
410  Scalar w = v.x * m[3] + v.y * m[7] + v.z * m[11] + m[15];
411  Vector3 result(v.x * m[0] + v.y * m[4] + v.z * m[8] + m[12],
412  v.x * m[1] + v.y * m[5] + v.z * m[9] + m[13],
413  v.x * m[2] + v.y * m[6] + v.z * m[10] + m[14]);
414 
415  // This is Skia's behavior, but it may be reasonable to allow UB for the w=0
416  // case.
417  if (w) {
418  w = 1 / w;
419  }
420  return result * w;
421  }

References m, impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

◆ operator*() [4/4]

constexpr Vector4 impeller::Matrix::operator* ( const Vector4 v) const
inlineconstexpr

Definition at line 402 of file matrix.h.

402  {
403  return Vector4(v.x * m[0] + v.y * m[4] + v.z * m[8] + v.w * m[12],
404  v.x * m[1] + v.y * m[5] + v.z * m[9] + v.w * m[13],
405  v.x * m[2] + v.y * m[6] + v.z * m[10] + v.w * m[14],
406  v.x * m[3] + v.y * m[7] + v.z * m[11] + v.w * m[15]);
407  }

References m, impeller::Vector4::w, impeller::Vector4::x, impeller::Vector4::y, and impeller::Vector4::z.

◆ operator+() [1/2]

Matrix impeller::Matrix::operator+ ( const Matrix m) const

Definition at line 88 of file matrix.cc.

88  {
89  return Matrix(
90  m[0] + o.m[0], m[1] + o.m[1], m[2] + o.m[2], m[3] + o.m[3], //
91  m[4] + o.m[4], m[5] + o.m[5], m[6] + o.m[6], m[7] + o.m[7], //
92  m[8] + o.m[8], m[9] + o.m[9], m[10] + o.m[10], m[11] + o.m[11], //
93  m[12] + o.m[12], m[13] + o.m[13], m[14] + o.m[14], m[15] + o.m[15] //
94  );
95 }

References m, and Matrix().

◆ operator+() [2/2]

Matrix impeller::Matrix::operator+ ( const Vector3 t) const
inline

Definition at line 394 of file matrix.h.

394 { return Translate(t); }

References Translate().

◆ operator-()

Matrix impeller::Matrix::operator- ( const Vector3 t) const
inline

Definition at line 396 of file matrix.h.

396 { return Translate(-t); }

References Translate().

◆ operator==()

constexpr bool impeller::Matrix::operator== ( const Matrix m) const
inlineconstexpr

Definition at line 376 of file matrix.h.

376  {
377  // clang-format off
378  return vec[0] == m.vec[0]
379  && vec[1] == m.vec[1]
380  && vec[2] == m.vec[2]
381  && vec[3] == m.vec[3];
382  // clang-format on
383  }

References m, and vec.

◆ Scale()

constexpr Matrix impeller::Matrix::Scale ( const Vector3 s) const
inlineconstexpr

Definition at line 247 of file matrix.h.

247  {
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  }

References m, Matrix(), impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

◆ Transform()

constexpr Quad impeller::Matrix::Transform ( const Quad quad) const
inlineconstexpr

Definition at line 452 of file matrix.h.

452  {
453  return {
454  *this * quad[0],
455  *this * quad[1],
456  *this * quad[2],
457  *this * quad[3],
458  };
459  }

Referenced by impeller::GaussianBlurFilterContents::CalculateUVs().

◆ TransformDirection() [1/3]

constexpr Vector2 impeller::Matrix::TransformDirection ( const Vector2 v) const
inlineconstexpr

Definition at line 448 of file matrix.h.

448  {
449  return Vector2(v.x * m[0] + v.y * m[4], v.x * m[1] + v.y * m[5]);
450  }

References m, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TransformDirection() [2/3]

constexpr Vector3 impeller::Matrix::TransformDirection ( const Vector3 v) const
inlineconstexpr

Definition at line 442 of file matrix.h.

442  {
443  return Vector3(v.x * m[0] + v.y * m[4] + v.z * m[8],
444  v.x * m[1] + v.y * m[5] + v.z * m[9],
445  v.x * m[2] + v.y * m[6] + v.z * m[10]);
446  }

References m, impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

◆ TransformDirection() [3/3]

constexpr Vector4 impeller::Matrix::TransformDirection ( const Vector4 v) const
inlineconstexpr

Definition at line 436 of file matrix.h.

436  {
437  return Vector4(v.x * m[0] + v.y * m[4] + v.z * m[8],
438  v.x * m[1] + v.y * m[5] + v.z * m[9],
439  v.x * m[2] + v.y * m[6] + v.z * m[10], v.w);
440  }

References m, impeller::Vector4::w, impeller::Vector4::x, impeller::Vector4::y, and impeller::Vector4::z.

Referenced by impeller::BorderMaskBlurFilterContents::GetFilterCoverage(), impeller::DirectionalMorphologyFilterContents::GetFilterCoverage(), impeller::BorderMaskBlurFilterContents::GetFilterSourceCoverage(), and impeller::DirectionalMorphologyFilterContents::GetFilterSourceCoverage().

◆ Translate()

constexpr Matrix impeller::Matrix::Translate ( const Vector3 t) const
inlineconstexpr

Definition at line 235 of file matrix.h.

235  {
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  }

References m, Matrix(), impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

Referenced by ImGui_ImplImpeller_RenderDrawData(), operator+(), and operator-().

◆ Transpose()

constexpr Matrix impeller::Matrix::Transpose ( ) const
inlineconstexpr

Definition at line 278 of file matrix.h.

278  {
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  }

References m.

Referenced by Decompose().

Member Data Documentation

◆ @13

union { ... }

◆ e

Scalar impeller::Matrix::e[4][4]

◆ m

◆ vec

Vector4 impeller::Matrix::vec[4]

Definition at line 41 of file matrix.h.

Referenced by operator!=(), operator==(), and impeller::testing::TEST_P().


The documentation for this struct was generated from the following files:
impeller::Matrix::m
Scalar m[16]
Definition: matrix.h:39
impeller::Matrix::Matrix
constexpr Matrix()
Definition: matrix.h:47
impeller::Scalar
float Scalar
Definition: scalar.h:18
impeller::Vector3::Combine
static constexpr Vector3 Combine(const Vector3 &a, Scalar aScale, const Vector3 &b, Scalar bScale)
Definition: vector.h:192
impeller::Vector2
Point Vector2
Definition: point.h:320
impeller::Matrix::MakeTranslation
static constexpr Matrix MakeTranslation(const Vector3 &t)
Definition: matrix.h:95
impeller::Matrix::e
Scalar e[4][4]
Definition: matrix.h:40
impeller::Matrix::vec
Vector4 vec[4]
Definition: matrix.h:41
impeller::Matrix::MakePerspective
static constexpr Matrix MakePerspective(Radians fov_y, Scalar aspect_ratio, Scalar z_near, Scalar z_far)
Definition: matrix.h:471
impeller::Matrix::Basis
constexpr Matrix Basis() const
The Matrix without its w components (without translation).
Definition: matrix.h:224
impeller::Point
TPoint< Scalar > Point
Definition: point.h:316
impeller::Matrix::Multiply
constexpr Matrix Multiply(const Matrix &o) const
Definition: matrix.h:256
impeller::Matrix::Translate
constexpr Matrix Translate(const Vector3 &t) const
Definition: matrix.h:235
impeller::ScalarNearlyZero
constexpr bool ScalarNearlyZero(Scalar x, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:25
impeller::Matrix::GetBasisZ
constexpr Vector3 GetBasisZ() const
Definition: matrix.h:304
impeller::Matrix::Invert
Matrix Invert() const
Definition: matrix.cc:97
scale
const Scalar scale
Definition: stroke_path_geometry.cc:297
impeller::Matrix::GetBasisY
constexpr Vector3 GetBasisY() const
Definition: matrix.h:302
impeller::Matrix::MakeScale
static constexpr Matrix MakeScale(const Vector3 &s)
Definition: matrix.h:104
impeller::Matrix::GetBasisX
constexpr Vector3 GetBasisX() const
Definition: matrix.h:300