| Flutter Impeller |

Public Member Functions | Static Public Member Functions | Public Attributes | List of all members
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< MatrixDecomposition > | Decompose () 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 | ( |  | ) |
| inline constexpr

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
| ) |  |
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| ) |  |
| inline static constexpr

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
| ) |  |
| inline static constexpr

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 | ) |
| inline static constexpr

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
| ) |  |
| inline static constexpr

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
| ) |  |
| inline static constexpr

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 | ) |
| inline static

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
| ) |  |
| inline static

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 | ) |
| inline static

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 | ) |
| inline static

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 | ) |
| inline static

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
| ) |  |
| inline static constexpr

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 | ) |
| inline static constexpr

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]

static constexpr Matrix impeller::Matrix::MakeScale | ( | const Vector3 & | s | ) |
| inline static constexpr

Definition at line 104 of file matrix.h.

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

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

Referenced by impeller::BM_StrokePolyline(), impeller::GaussianBlurFilterContents::CalculateUVs(), impeller::TRect< Scalar >::GetNormalizingTransform(), impeller::Entity::GetShaderTransform(), impeller::Snapshot::GetUVTransform(), MakeOrthographic(), MakeScale(), impeller::scene::importer::ParseGLTF(), impeller::scene::importer::ProcessNode(), impeller::SceneContents::Render(), impeller::TiledTextureContents::RenderToSnapshot(), impeller::TextureContents::RenderToSnapshot(), impeller::Canvas::Scale(), impeller::testing::TEST(), impeller::scene::testing::TEST_P(), and impeller::testing::TEST_P().

## ◆ MakeSkew()

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

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()

static constexpr Matrix impeller::Matrix::MakeTranslation | ( | const Vector3 & | t | ) |
| inline static constexpr

Definition at line 95 of file matrix.h.

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

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

Referenced by impeller::AdvancedBlend(), impeller::DlDispatcher::drawShadow(), impeller::AtlasContents::GenerateSubAtlas(), impeller::Entity::GetShaderTransform(), MakeOrthographic(), impeller::PipelineBlend(), impeller::scene::importer::ProcessNode(), impeller::SolidRRectBlurContents::Render(), impeller::TiledTextureContents::RenderToSnapshot(), impeller::TextureContents::RenderToSnapshot(), impeller::Contents::RenderToSnapshot(), impeller::Picture::Snapshot(), impeller::testing::TEST(), impeller::scene::testing::TEST_P(), impeller::testing::TEST_P(), and impeller::Canvas::Translate().

## ◆ Multiply()

constexpr Matrix impeller::Matrix::Multiply | ( | const Matrix & | o | ) | const
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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
| inline constexpr

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]

Definition at line 40 of file matrix.h.

Referenced by Decompose(), GetDeterminant(), GetMaxBasisLength(), GetMaxBasisLengthXY(), Matrix(), and std::operator<<().

## ◆ m

Scalar impeller::Matrix::m[16]

Definition at line 39 of file matrix.h.

Referenced by Basis(), GetBasisX(), GetBasisY(), GetBasisZ(), HasPerspective(), Invert(), IsAffine(), IsAligned(), IsIdentity(), IsTranslationScaleOnly(), MatrixNear(), Multiply(), operator!=(), operator*(), operator+(), operator==(), Scale(), impeller::scene::importer::ToFBMatrix(), impeller::scene::importer::ToFBMatrixUniquePtr(), impeller::scene::importer::ToMatrix(), TransformDirection(), Translate(), and Transpose().

## ◆ 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/geometry/matrix.h
- impeller/geometry/matrix.cc

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