- Qt 6.4
- Qt Quick
- QML Types
- matrix4x4
- Qt 6.4.3 Reference Documentation

# matrix4x4 QML Value Type

A matrix4x4 type is a 4-row and 4-column matrix. More...

## Detailed Description

A `matrix4x4` type has sixteen values, each accessible via the properties `m11` through `m44` in QML (in row/column order). Values of this type can be composed with the Qt.matrix4x4() function. Each attribute in a matrix4x4 is stored as a real (single-precision on ARM, double-precision on x86).

The matrix4x4 type has the following idempotent functions which can be invoked in QML:

Function Signature | Description | Example
--- | --- | ---
translate(vector3d vector) | Multiplies `this` matrix4x4 by another that translates coordinates by the components of `vector` |
     var m = Qt.matrix4x4();
     m.translate(Qt.vector3d(1,2,3));
     console.log(m.toString());
     // QMatrix4x4(1, 0, 0, 1, 0, 1, 0, 2, 0, 0, 1, 3, 0, 0, 0, 1)
rotate(real angle, vector3d axis) | Multiples `this` matrix4x4 by another that rotates coordinates through `angle` degrees about `axis` |
     var m = Qt.matrix4x4();
     m.rotate(180,Qt.vector3d(1,0,0));
     console.log(m.toString());
     // QMatrix4x4(1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1)
rotate(quaternion quaternion) | Multiples `this` matrix4x4 by another that rotates coordinates according to a specified `quaternion`. The `quaternion` is assumed to have been normalized. |
     var m = Qt.matrix4x4();
     m.rotate(Qt.quaternion(0.5,0.5,0.5,-0.5));
     console.log(m.toString());
     // QMatrix4x4(0, 1, 0, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 1)
scale(real factor) | Multiplies `this` matrix4x4 by another that scales coordinates by the given `factor` |
     var m = Qt.matrix4x4();
     m.scale(2);
     console.log(m.toString());
     // QMatrix4x4(2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1)
scale(real x, real y, real z) | Multiplies `this` matrix4x4 by another that scales coordinates by the components `x`, `y`, and `z` |
     var m = Qt.matrix4x4();
     m.scale(1,2,3);
     console.log(m.toString());
     // QMatrix4x4(1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1)
scale(vector3d vector) | Multiplies `this` matrix4x4 by another that scales coordinates by the components of `vector` |
     var m = Qt.matrix4x4();
     m.scale(Qt.vector3d(1,2,3));
     console.log(m.toString());
     // QMatrix4x4(1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1)
lookAt(vector3d eye, vector3d center, vector3d up) | Multiplies `this` matrix4x4 by a viewing matrix derived from an `eye` point. The `center` vector3d indicates the center of the view that the `eye` is looking at. The `up` vector3d indicates which direction should be considered up with respect to the `eye`. |
     var m = Qt.matrix4x4();
     m.lookAt(Qt.vector3d(1,2,3),Qt.vector3d(1,2,0),Qt.vector3d(0,1,0));
     console.log(m.toString());
     // QMatrix4x4(1, 0, 0, -1, 0, 1, 0, -2, 0, 0, 1, -3, 0, 0, 0, 1)
matrix4x4 times(matrix4x4 other) | Returns the matrix4x4 result of multiplying `this` matrix4x4 with the `other` matrix4x4 |
     var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
     var b = Qt.matrix4x4(4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19);
     var c = a.times(b);
     console.log(c.toString());
     // QMatrix4x4(120, 130, 140, 150, 280, 306, 332, 358, 440, 482,
     //524, 566, 600, 658, 716, 774)
vector4d times(vector4d vector) | Returns the vector4d result of transforming the `vector` according to `this` matrix4x4 with the matrix applied pre-vector |
     var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
     var b = Qt.vector4d(5,6,7,8);
     var c = a.times(b);
     console.log(c.toString()); // QVector4D(70, 174, 278, 382)
vector3d times(vector3d vector) | Returns the vector3d result of transforming the `vector` according to `this` matrix4x4 with the matrix applied pre-vector |
     var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
     var b = Qt.vector3d(5,6,7);
     var c = a.times(b);
     console.log(c.toString()); // QVector3D(0.155556, 0.437037, 0.718518)
matrix4x4 times(real factor) | Returns the matrix4x4 result of multiplying `this` matrix4x4 with the scalar `factor` |
     var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
     var b = 4.48;
     var c = a.times(b);
     console.log(c.toString());
     // QMatrix4x4(4.48, 8.96, 13.44, 17.92, 22.4, 26.88, 31.36, 35.84,
     // 40.32, 44.8, 49.28, 53.76, 58.24, 62.72, 67.2, 71.68)
matrix4x4 plus(matrix4x4 other) | Returns the matrix4x4 result of the addition of `this` matrix4x4 with the `other` matrix4x4 |
     var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
     var b = Qt.matrix4x4(5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20);
     var c = a.plus(b);
     console.log(c.toString());
     // QMatrix4x4(6, 8, 10, 12, 14, 16, 18, 20, 22,
     // 24, 26, 28, 30, 32, 34, 36)
matrix4x4 minus(matrix4x4 other) | Returns the matrix4x4 result of the subtraction of `other` matrix4x4 from `this` matrix4x4 |
     var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
     var b = Qt.matrix4x4(5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20);
     var c = a.minus(b);
     console.log(c.toString());
     // QMatrix4x4(-4, -4, -4, -4, -4, -4, -4, -4, -4,
     // -4, -4, -4, -4, -4, -4, -4)
vector4d row(int which) | Returns the vector4d row of `this` specified by `which`. Note: the `which` is 0-based access into the matrix. |
     var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
     var b = Qt.vector4d(a.m21, a.m22, a.m23, a.m24);
     var c = a.row(2); // zero based access!  so not equal to b
     console.log(b.toString() + " " + c.toString());
     // QVector4D(5, 6, 7, 8) QVector4D(9, 10, 11, 12)
vector4d column(int which) | Returns the vector4d column of `this` specified by `which`. Note: the `which` is 0-based access into the matrix. |
     var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
     var b = Qt.vector4d(a.m12, a.m22, a.m32, a.m42);
     var c = a.column(2); // zero based access!  so not equal to b
     console.log(b.toString() + " " + c.toString());
     // QVector4D(2, 6, 10, 14) QVector4D(3, 7, 11, 15)
real determinant() | Returns the determinant of `this` matrix4x4 |
     var a = Qt.matrix4x4(1,0,0,0,0,2,0,0,0,0,3,0,100,200,300,1);
     var b = a.determinant();
     console.log(b); // 6
matrix4x4 inverted() | Returns the inverse of `this` matrix4x4 if it exists, else the identity matrix. |
     var a = Qt.matrix4x4(1,0,0,0,0,2,0,0,0,0,3,0,100,200,300,1);
     var b = a.inverted();
     console.log(b.toString());
     // QMatrix4x4(1, 0, 0, 0, 0, 0.5, 0, 0, 0, 0, 0.333333, 0, -100,
     // -100, -100, 1)
matrix4x4 transposed() | Returns the transpose of `this` matrix4x4 |
     var a = Qt.matrix4x4(1,0,0,0,0,2,0,0,0,0,3,0,100,200,300,1);
     var b = a.transposed();
     console.log(b.toString());
     // QMatrix4x4(1, 0, 0, 100, 0, 2, 0, 200, 0, 0, 3, 300, 0, 0, 0, 1)
bool fuzzyEquals(matrix4x4 other, real epsilon) | Returns true if `this` matrix4x4 is approximately equal to the `other` matrix4x4. The approximation will be true if each attribute of `this` is within `epsilon` of the respective attribute of `other`. Note that `epsilon` is an optional argument, the default `epsilon` is 0.00001. |
     var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
     var b = Qt.matrix4x4(1.0001,2.0001,3.0002,4.0003,5.0001,6.0002,
                          7.0002,8.0004, 9.0001,10.0003,
                          11.0003,12.0004,13.0001,
                          14.0002,15.0003,16.0004);
     var c = a.fuzzyEquals(b);        // default epsilon
     var d = a.fuzzyEquals(b, 0.005); // supplied epsilon
     console.log(c + " " + d); // false true

This value type is provided by the QtQuick import.

See also QML Value Types.