Welcome to Python-flavored Magnum! Please note that, while already being rather stable, this functionality is still considered experimental and some APIs might get changed without preserving full backwards compatibility.

# magnum.Matrix4 class

3D float transformation matrix

## Static methods

def translation(vector: Vector3) -> Matrix4
3D translation matrix
def from_(rotation_scaling: Matrix3x3, translation: Vector3) -> Matrix4
Create a matrix from a rotation/scaling part and a translation part
def from_diagonal(diagonal: Vector4) -> Matrix4
Construct a diagonal matrix
def identity_init(value: float = 1.0) -> Matrix4
Construct an identity matrix
def look_at(eye: Vector3, target: Vector3, up: Vector3) -> Matrix4
Matrix oriented towards a specific point
size: Vector2, near: float, far: float) -> Matrix4
3D orthographic projection matrix
bottom_left: Vector2, top_right: Vector2, near: float, far: float) -> Matrix4
3D off-center orthographic projection matrix
size: Vector2, near: float, far: float) -> Matrix4
3D perspective projection matrix
fov: Rad, aspect_ratio: float, near: float, far: float) -> Matrix4
3D perspective projection matrix
bottom_left: Vector2, top_right: Vector2, near: float, far: float) -> Matrix4
3D off-center perspective projection matrix
def reflection(normal: Vector3) -> Matrix4
3D reflection matrix
def rotation(angle: Rad, normalized_axis: Vector3) -> Matrix4
3D rotation matrix
3D rotation matrix around the X axis
3D rotation matrix around the Y axis
3D rotation matrix around the Z axis
def scaling(vector: Vector3) -> Matrix4
3D scaling matrix
def shearing_xy(amount_x: float, amount_y: float) -> Matrix4
3D shearing matrix along the XY plane
def shearing_xz(amount_x: float, amount_z: float) -> Matrix4
3D shearning matrix along the XZ plane
def shearing_yz(amount_y: float, amount_z: float) -> Matrix4
3D shearing matrix along the YZ plane
def zero_init() -> Matrix4
Construct a zero-filled matrix

## Methods

def cofactor(self, col: int, row: int) -> float
Cofactor
def comatrix(self, /) -> Matrix4
Matrix of cofactors
def determinant(self, /) -> float
Determinant
def diagonal(self, /) -> Vector4
Values on diagonal
def flipped_cols(self, /) -> Matrix4
Matrix with flipped cols
def flipped_rows(self, /) -> Matrix4
Matrix with flipped rows
def inverted(self, /) -> Matrix4
Inverted matrix
self, /) -> Matrix4
Inverted orthogonal matrix
def inverted_rigid(self, /) -> Matrix4
Inverted rigid transformation matrix
def is_orthogonal(self, /) -> bool
Whether the matrix is orthogonal
self, /) -> bool
Check whether the matrix represents a rigid transformation
def normal_matrix(self, /) -> Matrix3x3
Normal matrix
def rotation(self, /) -> Matrix3x3
3D rotation part of the matrix
self, /) -> Matrix3x3
3D rotation part of the matrix assuming there is no scaling
def rotation_scaling(self, /) -> Matrix3x3
3D rotation and scaling part of the matrix
def rotation_shear(self, /) -> Matrix3x3
3D rotation and shear part of the matrix
def scaling(self, /) -> Vector3
Non-uniform scaling part of the matrix
def scaling_squared(self, /) -> Vector3
Non-uniform scaling part of the matrix, squared
def trace(self, /) -> float
Trace of the matrix
def transform_point(self, vector: Vector3) -> Vector3
Transform a 3D point with the matrix
def transform_vector(self, vector: Vector3) -> Vector3
Transform a 3D vector with the matrix
def transposed(self, /) -> Matrix4
Transposed matrix
def uniform_scaling(self, /) -> float
Uniform scaling part of the matrix
self, /) -> float
Uniform scaling part of the matrix, squared

## Special methods

def __add__(self, arg0: Matrix4, /) -> Matrix4
def __eq__(self, arg0: Matrix4x4, /) -> bool
Equality comparison
def __getitem__(self, arg0: int, /) -> Vector4
Column at given position
def __getitem__(self, arg0: typing.Tuple[int, int], /) -> float
Value at given col/row
def __getstate__(self, /) -> bytes
Dumps the in-memory representation of matrix components
def __iadd__(self, arg0: Matrix4, /) -> Matrix4
def __imul__(self, arg0: float, /) -> Matrix4
Multiply with a scalar and assign
def __init__(self, arg0: Matrix4d, /) -> None
Construct from different underlying type
def __init__(self, arg0: buffer, /) -> None
Construct from a buffer
def __init__(self, /) -> None
Default constructor
def __init__(self, arg0: float, /) -> None
Construct a matrix with one value for all components
def __init__(self, arg0: Vector4, arg1: Vector4, arg2: Vector4, arg3: Vector4, /) -> None
Construct from column vectors
def __init__(self, arg0: typing.Tuple[Vector4, Vector4, Vector4, Vector4], /) -> None
Construct from a column vector tuple
def __init__(self, arg0: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]], /) -> None
Construct from a column tuple
def __isub__(self, arg0: Matrix4, /) -> Matrix4
Subtract and assign a matrix
def __itruediv__(self, arg0: float, /) -> Matrix4
Divide with a scalar and assign
def __len__() -> int
Matrix column count. Returns 4.
def __matmul__(self, arg0: Matrix4, /) -> Matrix4
Multiply a matrix
def __mul__(self, arg0: float, /) -> Matrix4
Multiply with a scalar
def __mul__(self, arg0: Vector4, /) -> Vector4
Multiply a vector
def __ne__(self, arg0: Matrix4x4, /) -> bool
Non-equality comparison
def __neg__(self, /) -> Matrix4
Negated matrix
def __repr__(self, /) -> str
Object representation
def __rmul__(self, arg0: float, /) -> Matrix4
Multiply a scalar with a matrix
def __rtruediv__(self, arg0: float, /) -> Matrix4
Divide a matrix with a scalar and invert
def __setitem__(self, arg0: int, arg1: Vector4, /) -> None
Set a column at given position
def __setitem__(self, arg0: typing.Tuple[int, int], arg1: float, /) -> None
Set a value at given col/row
def __setstate__(self, arg0: bytes, /) -> None
Treats the data as the in-memory representation of matrix components
def __sub__(self, arg0: Matrix4, /) -> Matrix4
Subtract a matrix
def __truediv__(self, arg0: float, /) -> Matrix4
Divide with a scalar

## Properties

backward: Vector3 get set
Backward-pointing 3D vector
Right-pointing 3D vector
translation: Vector3 get set
3D translation part of the matrix
up: Vector3 get set
Up-pointing 3D vector

## Method documentation

### def magnum.Matrix4.reflection(normal: Vector3) -> Matrix4 staticmethod

3D reflection matrix

Exceptions
ValueError If `normal` is not normalized

### def magnum.Matrix4.inverted_orthogonal(self, /) -> Matrix4

Inverted orthogonal matrix

Exceptions
ValueError If the matrix is not orthogonal

### def magnum.Matrix4.inverted_rigid(self, /) -> Matrix4

Inverted rigid transformation matrix

Exceptions
ValueError If the matrix doesn’t represent a rigid transformation

### def magnum.Matrix4.rotation(self, /) -> Matrix3x3

3D rotation part of the matrix

Exceptions
ValueError If the normalized rotation part is not orthogonal

### def magnum.Matrix4.rotation_normalized(self, /) -> Matrix3x3

3D rotation part of the matrix assuming there is no scaling

Exceptions
ValueError If the rotation part is not orthogonal

### def magnum.Matrix4.uniform_scaling(self, /) -> float

Uniform scaling part of the matrix

Exceptions
ValueError If the matrix doesn’t have uniform scaling

### def magnum.Matrix4.uniform_scaling_squared(self, /) -> float

Uniform scaling part of the matrix, squared

Exceptions
ValueError If the matrix doesn’t have uniform scaling

### def magnum.Matrix4.__setstate__(self, arg0: bytes, /) -> None

Treats the data as the in-memory representation of matrix components

Exceptions
ValueError If the data size doesn’t match type size