| 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
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 | HasPerspective2D () const
constexpr bool | HasPerspective () const
constexpr bool | HasTranslation () const
constexpr bool | IsAligned2D (Scalar tolerance=0) 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
bool | Equals (const Matrix &matrix, Scalar epsilon=1e-5f) 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 Vector3 | TransformHomogenous (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 (Radians 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 229 of file matrix.h.

229 {
230 // clang-format off
231 return Matrix(
232 m[0], m[1], m[2], 0.0f,
233 m[4], m[5], m[6], 0.0f,
234 m[8], m[9], m[10], 0.0f,
235 0.0f, 0.0f, 0.0f, 1.0
236 );
237 // clang-format on
238 }

References m, and Matrix().

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

## ◆ Decompose()

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

Definition at line 200 of file matrix.cc.

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

References impeller::Vector3::Combine(), impeller::Vector3::Dot(), impeller::Vector3::e, e, impeller::Vector4::e, GetDeterminant(), impeller::Vector3::GetLength(), Invert(), 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().

## ◆ Equals()

bool impeller::Matrix::Equals | ( | const Matrix & | matrix,
|  | Scalar | epsilon = `1e-5f`
| ) |  | const
| inline

Definition at line 410 of file matrix.h.

410 {
411 const Scalar* a = m;
412 const Scalar* b = matrix.m;
413 return ScalarNearlyEqual(a[0], b[0], epsilon) &&
414 ScalarNearlyEqual(a[1], b[1], epsilon) &&
415 ScalarNearlyEqual(a[2], b[2], epsilon) &&
416 ScalarNearlyEqual(a[3], b[3], epsilon) &&
417 ScalarNearlyEqual(a[4], b[4], epsilon) &&
418 ScalarNearlyEqual(a[5], b[5], epsilon) &&
419 ScalarNearlyEqual(a[6], b[6], epsilon) &&
420 ScalarNearlyEqual(a[7], b[7], epsilon) &&
421 ScalarNearlyEqual(a[8], b[8], epsilon) &&
422 ScalarNearlyEqual(a[9], b[9], epsilon) &&
423 ScalarNearlyEqual(a[10], b[10], epsilon) &&
424 ScalarNearlyEqual(a[11], b[11], epsilon) &&
425 ScalarNearlyEqual(a[12], b[12], epsilon) &&
426 ScalarNearlyEqual(a[13], b[13], epsilon) &&
427 ScalarNearlyEqual(a[14], b[14], epsilon) &&
428 ScalarNearlyEqual(a[15], b[15], epsilon);
429 }

References impeller::saturated::b, m, and impeller::ScalarNearlyEqual().

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

## ◆ GetBasisX()

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

Definition at line 310 of file matrix.h.

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

References m.

Referenced by impeller::Paint::MaskBlurDescriptor::CreateMaskBlur(), and GetScale().

## ◆ GetBasisY()

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

Definition at line 312 of file matrix.h.

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

References m.

Referenced by impeller::Paint::MaskBlurDescriptor::CreateMaskBlur(), and GetScale().

## ◆ GetBasisZ()

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

Definition at line 314 of file matrix.h.

314 { 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 Decompose().

## ◆ GetDirectionScale()

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

Definition at line 321 of file matrix.h.

321 {
322 return 1.0f / (this->Basis().Invert() * direction.Normalize()).GetLength() *
323 direction.GetLength();
324 }

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

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

## ◆ GetMaxBasisLengthXY()

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

Definition at line 298 of file matrix.h.

298 {
299 // The full basis computation requires computing the squared scaling factor
300 // for translate/scale only matrices. This substantially limits the range of
301 // precision for small and large scales. Instead, check for the common cases
302 // and directly return the max scaling factor.
303 if (e[0][1] == 0 && e[1][0] == 0) {
304 return std::max(std::abs(e[0][0]), std::abs(e[1][1]));
305 }
306 return std::sqrt(std::max(e[0][0] * e[0][0] + e[0][1] * e[0][1],
307 e[1][0] * e[1][0] + e[1][1] * e[1][1]));
308 }

References e.

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

## ◆ GetScale()

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

Definition at line 316 of file matrix.h.

316 {
317 return Vector3(GetBasisX().GetLength(), GetBasisY().GetLength(),
318 GetBasisZ().GetLength());
319 }

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

Referenced by impeller::DlDispatcherBase::drawShadow().

## ◆ HasPerspective()

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

Definition at line 335 of file matrix.h.

335 {
336 return m[3] != 0 || m[7] != 0 || m[11] != 0 || m[15] != 1;
337 }

References m.

Referenced by impeller::DlDispatcherBase::drawDisplayList(), impeller::TextFrameDispatcher::drawDisplayList(), IsAligned(), and impeller::testing::TEST().

## ◆ HasPerspective2D()

constexpr bool impeller::Matrix::HasPerspective2D | ( |  | ) | const
| inlineconstexpr

Definition at line 331 of file matrix.h.

331 {
332 return m[3] != 0 || m[7] != 0 || m[15] != 1;
333 }

References m.

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

## ◆ HasTranslation()

constexpr bool impeller::Matrix::HasTranslation | ( |  | ) | const
| inlineconstexpr

Definition at line 339 of file matrix.h.

339 { return m[12] != 0 || m[13] != 0; }

References m.

## ◆ 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::Canvas::Restore(), impeller::ColorSourceContents::SetEffectTransform(), and impeller::testing::TEST().

## ◆ IsAffine()

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

Definition at line 326 of file matrix.h.

326 {
327 return (m[2] == 0 && m[3] == 0 && m[6] == 0 && m[7] == 0 && m[8] == 0 &&
328 m[9] == 0 && m[10] == 1 && m[11] == 0 && m[14] == 0 && m[15] == 1);
329 }

References m.

## ◆ IsAligned()

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

Definition at line 356 of file matrix.h.

356 {
357 if (HasPerspective()) {
358 return false;
359 }
360 int v[] = {!ScalarNearlyZero(m[0], tolerance), //
361 !ScalarNearlyZero(m[1], tolerance), //
362 !ScalarNearlyZero(m[2], tolerance), //
363 !ScalarNearlyZero(m[4], tolerance), //
364 !ScalarNearlyZero(m[5], tolerance), //
365 !ScalarNearlyZero(m[6], tolerance), //
366 !ScalarNearlyZero(m[8], tolerance), //
367 !ScalarNearlyZero(m[9], tolerance), //
368 !ScalarNearlyZero(m[10], tolerance)};
369 // Check if all three basis vectors are aligned to an axis.
370 if (v[0] + v[1] + v[2] != 1 || //
371 v[3] + v[4] + v[5] != 1 || //
372 v[6] + v[7] + v[8] != 1) {
373 return false;
374 }
375 // Ensure that none of the basis vectors overlap.
376 if (v[0] + v[3] + v[6] != 1 || //
377 v[1] + v[4] + v[7] != 1 || //
378 v[2] + v[5] + v[8] != 1) {
379 return false;
380 }
381 return true;
382 }

References HasPerspective(), m, and impeller::ScalarNearlyZero().

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

## ◆ IsAligned2D()

constexpr bool impeller::Matrix::IsAligned2D | ( | Scalar | tolerance = `0` | ) | const
| inlineconstexpr

Definition at line 341 of file matrix.h.

341 {
342 if (HasPerspective2D()) {
343 return false;
344 }
345 if (ScalarNearlyZero(m[1], tolerance) &&
346 ScalarNearlyZero(m[4], tolerance)) {
347 return true;
348 }
349 if (ScalarNearlyZero(m[0], tolerance) &&
350 ScalarNearlyZero(m[5], tolerance)) {
351 return true;
352 }
353 return false;
354 }

References HasPerspective2D(), m, and impeller::ScalarNearlyZero().

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

## ◆ IsIdentity()

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

Definition at line 384 of file matrix.h.

384 {
385 return (
386 // clang-format off
387 m[0] == 1.0f && m[1] == 0.0f && m[2] == 0.0f && m[3] == 0.0f &&
388 m[4] == 0.0f && m[5] == 1.0f && m[6] == 0.0f && m[7] == 0.0f &&
389 m[8] == 0.0f && m[9] == 0.0f && m[10] == 1.0f && m[11] == 0.0f &&
390 m[12] == 0.0f && m[13] == 0.0f && m[14] == 0.0f && m[15] == 1.0f
391 // clang-format on
392 );
393 }

References m.

Referenced by impeller::MatrixFilterContents::IsTranslationOnly(), impeller::testing::TEST(), 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 397 of file matrix.h.

397 {
398 return (
399 // clang-format off
400 m[0] != 0.0 && m[1] == 0.0 && m[2] == 0.0 && m[3] == 0.0 &&
401 m[4] == 0.0 && m[5] != 0.0 && m[6] == 0.0 && m[7] == 0.0 &&
402 m[8] == 0.0 && m[9] == 0.0 && m[10] != 0.0 && m[11] == 0.0 &&
403 m[15] == 1.0
404 // clang-format on
405 );
406 }

References m.

Referenced by impeller::TextContents::Render(), and impeller::testing::TEST().

## ◆ 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(), impeller::TextFrameDispatcher::transform2DAffine(), and impeller::TextFrameDispatcher::transformFullPerspective().

## ◆ MakeLookAt()

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

Definition at line 558 of file matrix.h.

560 {
561 Vector3 forward = (target - position).Normalize();
562 Vector3 right = up.Cross(forward);
563 up = forward.Cross(right);
564
565 // clang-format off
566 return {
567 right.x, up.x, forward.x, 0.0f,
568 right.y, up.y, forward.y, 0.0f,
569 right.z, up.z, forward.z, 0.0f,
570 -right.Dot(position), -up.Dot(position), -forward.Dot(position), 1.0f
571 };
572 // clang-format on
573 }

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

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

## ◆ MakeOrthographic()

template<class T >

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

Definition at line 523 of file matrix.h.

523 {
524 // Per assumptions about NDC documented above.
525 const auto scale =
526 MakeScale({2.0f / static_cast<Scalar>(size.width),
527 -2.0f / static_cast<Scalar>(size.height), 0.0f});
528 const auto translate = MakeTranslation({-1.0f, 1.0f, 0.5f});
529 return translate * scale;
530 }

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 532 of file matrix.h.

535 {
536 Scalar height = std::tan(fov_y.radians * 0.5f);
537 Scalar width = height * aspect_ratio;
538
539 // clang-format off
540 return {
541 1.0f / width, 0.0f, 0.0f, 0.0f,
542 0.0f, 1.0f / height, 0.0f, 0.0f,
543 0.0f, 0.0f, z_far / (z_far - z_near), 1.0f,
544 0.0f, 0.0f, -(z_far * z_near) / (z_far - z_near), 0.0f,
545 };
546 // clang-format on
547 }

References impeller::Radians::radians.

Referenced by 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 550 of file matrix.h.

553 {
554 return MakePerspective(fov_y, static_cast<Scalar>(size.width) / size.height,
555 z_near, z_far);
556 }

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::testing::TEST().

## ◆ MakeRotation() [2/2]

static Matrix impeller::Matrix::MakeRotation | ( | Radians | radians,
|  | const Vector4 & | r
| ) |  |
| inlinestatic

Definition at line 151 of file matrix.h.

151 {
152 const Vector4 v = r.Normalize();
153
154 const Vector2 cos_sin = CosSin(radians);
155 const Scalar cosine = cos_sin.x;
156 const Scalar cosp = 1.0f - cosine;
157 const Scalar sine = cos_sin.y;
158
159 // clang-format off
160 return Matrix(
161 cosine + cosp * v.x * v.x,
162 cosp * v.x * v.y + v.z * sine,
163 cosp * v.x * v.z - v.y * sine,
164 0.0f,
165
166 cosp * v.x * v.y - v.z * sine,
167 cosine + cosp * v.y * v.y,
168 cosp * v.y * v.z + v.x * sine,
169 0.0f,
170
171 cosp * v.x * v.z + v.y * sine,
172 cosp * v.y * v.z - v.x * sine,
173 cosine + cosp * v.z * v.z,
174 0.0f,
175
176 0.0f,
177 0.0f,
178 0.0f,
179 1.0f);
180 // clang-format on
181 }

References Matrix(), impeller::Vector4::Normalize(), impeller::TPoint< T >::x, impeller::Vector4::x, impeller::TPoint< T >::y, impeller::Vector4::y, and impeller::Vector4::z.

## ◆ MakeRotationX()

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

Definition at line 183 of file matrix.h.

183 {
184 const Vector2 cos_sin = CosSin(r);
185 const Scalar cosine = cos_sin.x;
186 const Scalar sine = cos_sin.y;
187
188 // clang-format off
189 return Matrix(
190 1.0f, 0.0f, 0.0f, 0.0f,
191 0.0f, cosine, sine, 0.0f,
192 0.0f, -sine, cosine, 0.0f,
193 0.0f, 0.0f, 0.0f, 1.0f
194 );
195 // clang-format on
196 }

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

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

## ◆ MakeRotationY()

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

Definition at line 198 of file matrix.h.

198 {
199 const Vector2 cos_sin = CosSin(r);
200 const Scalar cosine = cos_sin.x;
201 const Scalar sine = cos_sin.y;
202
203 // clang-format off
204 return Matrix(
205 cosine, 0.0f, -sine, 0.0f,
206 0.0f, 1.0f, 0.0f, 0.0f,
207 sine, 0.0f, cosine, 0.0f,
208 0.0f, 0.0f, 0.0f, 1.0f
209 );
210 // clang-format on
211 }

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

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

## ◆ MakeRotationZ()

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

Definition at line 213 of file matrix.h.

213 {
214 const Vector2 cos_sin = CosSin(r);
215 const Scalar cosine = cos_sin.x;
216 const Scalar sine = cos_sin.y;
217
218 // clang-format off
219 return Matrix (
220 cosine, sine, 0.0f, 0.0f,
221 -sine, cosine, 0.0f, 0.0f,
222 0.0f, 0.0f, 1.0f, 0.0f,
223 0.0f, 0.0f, 0.0f, 1.0
224 );
225 // clang-format on
226 }

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

Referenced by impeller::Canvas::Rotate(), impeller::TextFrameDispatcher::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]

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

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::GaussianBlurFilterContents::CalculateUVs(), impeller::TRect< Scalar >::GetNormalizingTransform(), impeller::Entity::GetShaderTransform(), impeller::Snapshot::GetUVTransform(), MakeOrthographic(), MakeScale(), impeller::TiledTextureContents::RenderToSnapshot(), impeller::TextureContents::RenderToSnapshot(), impeller::Canvas::Scale(), impeller::testing::TEST(), and impeller::testing::TEST_P().

## ◆ 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::TextFrameDispatcher::skew(), impeller::testing::TEST(), and impeller::testing::TEST_P().

## ◆ MakeTranslation()

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

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::DlDispatcherBase::drawShadow(), impeller::Canvas::DrawTextFrame(), impeller::TextFrameDispatcher::drawTextFrame(), impeller::Entity::GetShaderTransform(), MakeOrthographic(), impeller::PipelineBlend(), impeller::SolidRRectBlurContents::Render(), impeller::TiledTextureContents::RenderToSnapshot(), impeller::TextureContents::RenderToSnapshot(), impeller::Contents::RenderToSnapshot(), impeller::Canvas::Restore(), impeller::Canvas::SaveLayer(), impeller::testing::TEST(), impeller::testing::TEST_P(), and impeller::Canvas::Translate().

## ◆ Multiply()

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

Definition at line 261 of file matrix.h.

261 {
262 // clang-format off
263 return Matrix(
264 m[0] * o.m[0] + m[4] * o.m[1] + m[8] * o.m[2] + m[12] * o.m[3],
265 m[1] * o.m[0] + m[5] * o.m[1] + m[9] * o.m[2] + m[13] * o.m[3],
266 m[2] * o.m[0] + m[6] * o.m[1] + m[10] * o.m[2] + m[14] * o.m[3],
267 m[3] * o.m[0] + m[7] * o.m[1] + m[11] * o.m[2] + m[15] * o.m[3],
268 m[0] * o.m[4] + m[4] * o.m[5] + m[8] * o.m[6] + m[12] * o.m[7],
269 m[1] * o.m[4] + m[5] * o.m[5] + m[9] * o.m[6] + m[13] * o.m[7],
270 m[2] * o.m[4] + m[6] * o.m[5] + m[10] * o.m[6] + m[14] * o.m[7],
271 m[3] * o.m[4] + m[7] * o.m[5] + m[11] * o.m[6] + m[15] * o.m[7],
272 m[0] * o.m[8] + m[4] * o.m[9] + m[8] * o.m[10] + m[12] * o.m[11],
273 m[1] * o.m[8] + m[5] * o.m[9] + m[9] * o.m[10] + m[13] * o.m[11],
274 m[2] * o.m[8] + m[6] * o.m[9] + m[10] * o.m[10] + m[14] * o.m[11],
275 m[3] * o.m[8] + m[7] * o.m[9] + m[11] * o.m[10] + m[15] * o.m[11],
276 m[0] * o.m[12] + m[4] * o.m[13] + m[8] * o.m[14] + m[12] * o.m[15],
277 m[1] * o.m[12] + m[5] * o.m[13] + m[9] * o.m[14] + m[13] * o.m[15],
278 m[2] * o.m[12] + m[6] * o.m[13] + m[10] * o.m[14] + m[14] * o.m[15],
279 m[3] * o.m[12] + m[7] * o.m[13] + m[11] * o.m[14] + m[15] * o.m[15]);
280 // clang-format on
281 }

References m, and Matrix().

Referenced by operator*().

## ◆ operator!=()

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

Definition at line 440 of file matrix.h.

440 {
441 // clang-format off
442 return vec[0] != m.vec[0]
443 || vec[1] != m.vec[1]
444 || vec[2] != m.vec[2]
445 || vec[3] != m.vec[3];
446 // clang-format on
447 }

References m, and vec.

## ◆ operator*() [1/4]

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

Definition at line 453 of file matrix.h.

453 { return Multiply(m); }

References m, and Multiply().

## ◆ operator*() [2/4]

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

Definition at line 478 of file matrix.h.

478 {
479 Scalar w = v.x * m[3] + v.y * m[7] + m[15];
480 Point result(v.x * m[0] + v.y * m[4] + m[12],
481 v.x * m[1] + v.y * m[5] + m[13]);
482
483 // This is Skia's behavior, but it may be reasonable to allow UB for the w=0
484 // case.
485 if (w) {
486 w = 1 / w;
487 }
488 return result * w;
489 }

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 464 of file matrix.h.

464 {
465 Scalar w = v.x * m[3] + v.y * m[7] + v.z * m[11] + m[15];
466 Vector3 result(v.x * m[0] + v.y * m[4] + v.z * m[8] + m[12],
467 v.x * m[1] + v.y * m[5] + v.z * m[9] + m[13],
468 v.x * m[2] + v.y * m[6] + v.z * m[10] + m[14]);
469
470 // This is Skia's behavior, but it may be reasonable to allow UB for the w=0
471 // case.
472 if (w) {
473 w = 1 / w;
474 }
475 return result * w;
476 }

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 457 of file matrix.h.

457 {
458 return Vector4(v.x * m[0] + v.y * m[4] + v.z * m[8] + v.w * m[12],
459 v.x * m[1] + v.y * m[5] + v.z * m[9] + v.w * m[13],
460 v.x * m[2] + v.y * m[6] + v.z * m[10] + v.w * m[14],
461 v.x * m[3] + v.y * m[7] + v.z * m[11] + v.w * m[15]);
462 }

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 449 of file matrix.h.

449 { return Translate(t); }

References Translate().

## ◆ operator-()

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

Definition at line 451 of file matrix.h.

451 { return Translate(-t); }

References Translate().

## ◆ operator==()

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

Definition at line 431 of file matrix.h.

431 {
432 // clang-format off
433 return vec[0] == m.vec[0]
434 && vec[1] == m.vec[1]
435 && vec[2] == m.vec[2]
436 && vec[3] == m.vec[3];
437 // clang-format on
438 }

References m, and vec.

## ◆ Scale()

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

Definition at line 252 of file matrix.h.

252 {
253 // clang-format off
254 return Matrix(m[0] * s.x, m[1] * s.x, m[2] * s.x, m[3] * s.x,
255 m[4] * s.y, m[5] * s.y, m[6] * s.y, m[7] * s.y,
256 m[8] * s.z, m[9] * s.z, m[10] * s.z, m[11] * s.z,
257 m[12] , m[13] , m[14] , m[15] );
258 // clang-format on
259 }

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

Referenced by impeller::TextFrameDispatcher::scale().

## ◆ Transform()

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

Definition at line 513 of file matrix.h.

513 {
514 return {
515 *this * quad[0],
516 *this * quad[1],
517 *this * quad[2],
518 *this * quad[3],
519 };
520 }

Referenced by impeller::GaussianBlurFilterContents::CalculateUVs(), and impeller::testing::TEST_P().

## ◆ TransformDirection() [1/3]

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

Definition at line 509 of file matrix.h.

509 {
510 return Vector2(v.x * m[0] + v.y * m[4], v.x * m[1] + v.y * m[5]);
511 }

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 503 of file matrix.h.

503 {
504 return Vector3(v.x * m[0] + v.y * m[4] + v.z * m[8],
505 v.x * m[1] + v.y * m[5] + v.z * m[9],
506 v.x * m[2] + v.y * m[6] + v.z * m[10]);
507 }

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 497 of file matrix.h.

497 {
498 return Vector4(v.x * m[0] + v.y * m[4] + v.z * m[8],
499 v.x * m[1] + v.y * m[5] + v.z * m[9],
500 v.x * m[2] + v.y * m[6] + v.z * m[10], v.w);
501 }

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

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

## ◆ TransformHomogenous()

constexpr Vector3 impeller::Matrix::TransformHomogenous | ( | const Point & | v | ) | const
| inlineconstexpr

Definition at line 491 of file matrix.h.

491 {
492 return Vector3(v.x * m[0] + v.y * m[4] + m[12],
493 v.x * m[1] + v.y * m[5] + m[13],
494 v.x * m[3] + v.y * m[7] + m[15]);
495 }

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

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

## ◆ Translate()

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

Definition at line 240 of file matrix.h.

240 {
241 // clang-format off
242 return Matrix(m[0], m[1], m[2], m[3],
243 m[4], m[5], m[6], m[7],
244 m[8], m[9], m[10], m[11],
245 m[0] * t.x + m[4] * t.y + m[8] * t.z + m[12],
246 m[1] * t.x + m[5] * t.y + m[9] * t.z + m[13],
247 m[2] * t.x + m[6] * t.y + m[10] * t.z + m[14],
248 m[3] * t.x + m[7] * t.y + m[11] * t.z + m[15]);
249 // clang-format on
250 }

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

Referenced by ImGui_ImplImpeller_RenderDrawData(), operator+(), operator-(), impeller::testing::TEST(), and impeller::TextFrameDispatcher::translate().

## ◆ Transpose()

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

Definition at line 283 of file matrix.h.

283 {
284 // clang-format off
285 return {
286 m[0], m[4], m[8], m[12],
287 m[1], m[5], m[9], m[13],
288 m[2], m[6], m[10], m[14],
289 m[3], m[7], m[11], m[15],
290 };
291 // clang-format on
292 }

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(), GetMaxBasisLengthXY(), Matrix(), std::operator<<(), and impeller::testing::TEST().

## ◆ m

Scalar impeller::Matrix::m[16]

Definition at line 39 of file matrix.h.

Referenced by Basis(), Equals(), impeller::interop::FromImpellerType(), GetBasisX(), GetBasisY(), GetBasisZ(), impeller::interop::DisplayListBuilder::GetTransform(), HasPerspective(), HasPerspective2D(), HasTranslation(), Invert(), IsAffine(), IsAligned(), IsAligned2D(), IsIdentity(), IsTranslationScaleOnly(), MatrixNear(), Multiply(), operator!=(), operator*(), operator+(), operator==(), Scale(), impeller::interop::DisplayListBuilder::SetTransform(), impeller::testing::TEST(), impeller::testing::TEST_P(), impeller::interop::ToSkMatrix(), TransformDirection(), TransformHomogenous(), Translate(), and Transpose().

## ◆ vec

Vector4 impeller::Matrix::vec[4]

Definition at line 41 of file matrix.h.

Referenced by operator!=(), operator==(), impeller::testing::TEST(), 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::HasPerspective
constexpr bool HasPerspective() const
Definition: matrix.h:335
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:331
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:532
impeller::Matrix::Basis
constexpr Matrix Basis() const
The Matrix without its w components (without translation).
Definition: matrix.h:229
impeller::Point
TPoint< Scalar > Point
Definition: point.h:327
impeller::Matrix::Multiply
constexpr Matrix Multiply(const Matrix &o) const
Definition: matrix.h:261
impeller::Matrix::Translate
constexpr Matrix Translate(const Vector3 &t) const
Definition: matrix.h:240
impeller::ScalarNearlyZero
constexpr bool ScalarNearlyZero(Scalar x, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:30
impeller::Matrix::GetBasisZ
constexpr Vector3 GetBasisZ() const
Definition: matrix.h:314
impeller::Matrix::Invert
Matrix Invert() const
Definition: matrix.cc:97
impeller::saturated::b
SI b
Definition: saturated_math.h:87
scale
const Scalar scale
Definition: stroke_path_geometry.cc:301
impeller::ScalarNearlyEqual
constexpr bool ScalarNearlyEqual(Scalar x, Scalar y, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:35
impeller::Matrix::GetBasisY
constexpr Vector3 GetBasisY() const
Definition: matrix.h:312
impeller::Matrix::MakeScale
static constexpr Matrix MakeScale(const Vector3 &s)
Definition: matrix.h:104
impeller::Matrix::GetBasisX
constexpr Vector3 GetBasisX() const
Definition: matrix.h:310
impeller::Matrix::HasPerspective2D
constexpr bool HasPerspective2D() const
Definition: matrix.h:331