Module Gg.M4

4D square matrices.

type t = m4

The type for 4D square matrices.

val dim : int

dim is the dimension of rows and columns.

type v = v4

The type for rows and columns as vectors.

Constructors, accessors and constants

val v : float -> float -> float -> float -> float -> float -> float -> float -> float -> float -> float -> float -> float -> float -> float -> float -> m4

v e00 e01 e02 e03 e10 e11 e12 e13 e20 e21 e22 e23 e30 e31 e32 e33 is a matrix whose components are specified in row-major order

val of_rows : v4 -> v4 -> v4 -> v4 -> m4

of_rows r0 r1 r2 r3 is the matrix whose rows are r0, r1, r2 and r3.

val of_cols : v4 -> v4 -> v4 -> v4 -> m4

of_cols c0 c1 c2 c3 is the matrix whose columns are c0, c1, c2 and c3.

val el : int -> int -> m4 -> float

el i j a is the element aij. See also the direct element accessors.

Raises Invalid_argument if i or j is not in [0;dim[.

val row : int -> m4 -> v

row i a is the ith row of a.

Raises Invalid_argument if i is not in [0;dim[.

val col : int -> m4 -> v

col j a is the jth column of a.

Raises Invalid_argument if j is not in [0;dim[.

val zero : m4

zero is the neutral element for add.

val id : m4

id is the identity matrix, the neutral element for mul.

val of_m3_v3 : m3 -> v3 -> m4

of_m3_v3 m v is the matrix whose first three rows are those of m,v side by side and the fourth is 0 0 0 1.

val of_quat : quat -> m4

to_quat q is the rotation of the unit quaternion q as 4D matrix.

Functions

val neg : m4 -> m4

neg a is the negated matrix -a.

val add : m4 -> m4 -> m4

add a b is the matrix addition a + b.

val sub : m4 -> m4 -> m4

sub a b is the matrix subtraction a - b.

val mul : m4 -> m4 -> m4

mul a b is the matrix multiplication a * b.

val emul : m4 -> m4 -> m4

emul a b is the element wise multiplication of a and b.

val ediv : m4 -> m4 -> m4

ediv a b is the element wise division of a and b.

val smul : float -> m4 -> m4

smul s a is a's elements multiplied by the scalar s.

val transpose : m4 -> m4

transpose a is the transpose aT.

val trace : m4 -> float

trace a is the matrix trace trace(a).

val det : m4 -> float

det a is the determinant |a|.

val inv : m4 -> m4

inv a is the inverse matrix a-1.

2D space transformations

val move2 : v2 -> m4

See M3.move2.

val rot2 : ?pt:p2 -> float -> m4

See M3.rot2.

val scale2 : v2 -> m4

See M2.scale2.

val rigid2 : move:v2 -> rot:float -> m4

See M3.rigid2.

val srigid2 : move:v2 -> rot:float -> scale:v2 -> m4

See M3.srigid2.

3D space transformations

val move3 : v3 -> m4

move d translates 3D space in the x, y and z dimensions according to d.

val rot3_map : v3 -> v3 -> m4

See M3.rot3_map.

val rot3_axis : v3 -> float -> m4

See M3.rot3_axis.

val rot3_zyx : v3 -> m4

See M3.rot3_zyx.

val scale3 : v3 -> m4

See M3.scale3.

val rigid3 : move:v3 -> rot:(v3 * float) -> m4

rigid3 move rot is the rigid body transformation of 3D space that rotates by the axis/radian angle rot and then translates by move.

val rigid3q : move:v3 -> rot:quat -> m4

rigid3q move rot is the rigid body transformation of 3D space that rotates by the quaternion rot and then translates by move.

val srigid3 : move:v3 -> rot:(v3 * float) -> scale:v3 -> m4

srigid3 scale move rot scale is like rigid3 but starts by scaling according to scale.

val srigid3q : move:v3 -> rot:quat -> scale:v3 -> m4

srigid3q move rot scale is like rigid3q but starts by scaling according to scale.

3D space projections

Projection matrices assume a right-handed coordinate system with the eye at the origin looking down the z-axis.

val ortho : left:float -> right:float -> bot:float -> top:float -> near:float -> far:float -> m4

ortho left right bot top near far maps the axis aligned box with corners (left, bot, -near) and (right, top, -far) to the axis aligned cube with corner (-1, -1, -1) and (1, 1, 1).

val persp : left:float -> right:float -> bot:float -> top:float -> near:float -> far:float -> m4

persp left right bot top near far maps the frustum with top of the underlying pyramid at the origin, near clip rectangle corners (left, bot, -near), (right, top, -near) and far plane at -far to the axis aligned cube with corners (-1, -1, -1) and (1,1,1).

4D space transformations

val scale4 : v4 -> m4

scale4 s scales 4D space in the x, y, z and w dimensions according to s.

Traversal

val map : (float -> float) -> m4 -> m4

map f a is the element wise application of f to a.

val mapi : (int -> int -> float -> float) -> m4 -> m4

mapi f a is like map but the element indices are also given.

val fold : ('a -> float -> 'a) -> 'a -> m4 -> 'a

fold f acc a is f (...(f (f acc a00) a10)...).

val foldi : ('a -> int -> int -> float -> 'a) -> 'a -> m4 -> 'a

foldi f acc a is f (...(f (f acc 0 0 a00) 1 0 a10)...).

val iter : (float -> unit) -> m4 -> unit

iter f a is f a00; f a10; ...

val iteri : (int -> int -> float -> unit) -> m4 -> unit

iteri f a is f 0 0 a00; f 1 0 a10; ...

Predicates and comparisons

val for_all : (float -> bool) -> m4 -> bool

for_all p a is p a00 && p a10 && ...

val exists : (float -> bool) -> m4 -> bool

exists p a is p a00 || p a10 || ...

val equal : m4 -> m4 -> bool

equal a b is a = b.

val equal_f : (float -> float -> bool) -> m4 -> m4 -> bool

equal_f eq a b tests a and b like equal but uses eq to test floating point values.

val compare : m4 -> m4 -> int

compare a b is Stdlib.compare a b. That is lexicographic comparison in column-major order.

val compare_f : (float -> float -> int) -> m4 -> m4 -> int

compare_f cmp a b compares a and b like compare but uses cmp to compare floating point values.

Formatters

val pp : Stdlib.Format.formatter -> m4 -> unit

pp ppf a prints a textual representation of a on ppf.

val pp_f : (Stdlib.Format.formatter -> float -> unit) -> Stdlib.Format.formatter -> m4 -> unit

pp_f pp_e ppf a prints a like pp but uses pp_e to print floating point values.

Element accessors

val e00 : m4 -> float
val e01 : m4 -> float
val e02 : m4 -> float
val e03 : m4 -> float
val e10 : m4 -> float
val e11 : m4 -> float
val e12 : m4 -> float
val e13 : m4 -> float
val e20 : m4 -> float
val e21 : m4 -> float
val e22 : m4 -> float
val e23 : m4 -> float
val e30 : m4 -> float
val e31 : m4 -> float
val e32 : m4 -> float
val e33 : m4 -> float