org.sunflow.math

## Class Matrix4

- java.lang.Object
- - org.sunflow.math.Matrix4

    public final class Matrix4
    extends java.lang.Object

This class is used to represent general affine transformations in 3D. The bottom row of the matrix is assumed to be [0,0,0,1]. Note that the rotation matrices assume a right-handed convention.

### Field Summary

Fields
`static Matrix4` `IDENTITY`
`static Matrix4` `ZERO`

### Constructor Summary

Constructors
Constructor and Description
`Matrix4(float[] m, boolean rowMajor)` Initialize a matrix from the specified 16 element array.
`Matrix4(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23)` Creates a matrix with the specified elements

### Method Summary

Methods
`float[]` `asColMajor()`
`float[]` `asRowMajor()`
`static Matrix4` `blend(Matrix4 m0, Matrix4 m1, float t)`
`float` `determinant()` Compute the matrix determinant.
`boolean` `equals(Matrix4 m)`
`static Matrix4` `fromBasis(OrthoNormalBasis basis)` Creates a rotation matrix from an OrthonormalBasis.
`Matrix4` `inverse()` Compute the inverse of this matrix and return it as a new object.
`boolean` `isIndentity()`
`static Matrix4` `lookAt(Point3 eye, Point3 target, Vector3 up)` Creates a camera positioning matrix from the given eye and target points and up vector.
`Matrix4` `multiply(Matrix4 m)` Computes this*m and return the result as a new Matrix4
`static Matrix4` `rotate(float x, float y, float z, float theta)` Creates a rotation matrix about the specified axis.
`static Matrix4` `rotateX(float theta)` Creates a rotation matrix about the X axis.
`static Matrix4` `rotateY(float theta)` Creates a rotation matrix about the Y axis.
`static Matrix4` `rotateZ(float theta)` Creates a rotation matrix about the Z axis.
`static Matrix4` `scale(float s)` Create a uniform scaling matrix.
`static Matrix4` `scale(float sx, float sy, float sz)` Creates a non-uniform scaling matrix.
`BoundingBox` `transform(BoundingBox b)` Transforms each corner of the specified axis-aligned bounding box and returns a new bounding box which incloses the transformed corners.
`Point3` `transformP(Point3 p)` Computes this*p and returns the result as a new Point3 object.
`float` `transformPX(float x, float y, float z)` Computes the x component of this*(x,y,z,1).
`float` `transformPY(float x, float y, float z)` Computes the y component of this*(x,y,z,1).
`float` `transformPZ(float x, float y, float z)` Computes the z component of this*(x,y,z,1).
`Vector3` `transformTransposeV(Vector3 v)` Computes (this^T)*v and returns the result as a new Vector3 object.
`float` `transformTransposeVX(float x, float y, float z)` Computes the x component of (this^T)*(x,y,z,0).
`float` `transformTransposeVY(float x, float y, float z)` Computes the y component of (this^T)*(x,y,z,0).
`float` `transformTransposeVZ(float x, float y, float z)` Computes the z component of (this^T)*(x,y,z,0).
`Vector3` `transformV(Vector3 v)` Computes this*v and returns the result as a new Vector3 object.
`float` `transformVX(float x, float y, float z)` Computes the x component of this*(x,y,z,0).
`float` `transformVY(float x, float y, float z)` Computes the y component of this*(x,y,z,0).
`float` `transformVZ(float x, float y, float z)` Computes the z component of this*(x,y,z,0).
`static Matrix4` `translation(float x, float y, float z)` Create a translation matrix for the specified vector.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### ZERO

    public static final Matrix4 ZERO

#### IDENTITY

    public static final Matrix4 IDENTITY

### Constructor Detail

#### Matrix4

    public Matrix4(float m00,
           float m01,
           float m02,
           float m03,
           float m10,
           float m11,
           float m12,
           float m13,
           float m20,
           float m21,
           float m22,
           float m23)

Creates a matrix with the specified elements

Parameters:
  `m00` - value at row 0, col 0
  `m01` - value at row 0, col 1
  `m02` - value at row 0, col 2
  `m03` - value at row 0, col 3
  `m10` - value at row 1, col 0
  `m11` - value at row 1, col 1
  `m12` - value at row 1, col 2
  `m13` - value at row 1, col 3
  `m20` - value at row 2, col 0
  `m21` - value at row 2, col 1
  `m22` - value at row 2, col 2
  `m23` - value at row 2, col 3

#### Matrix4

    public Matrix4(float[] m,
           boolean rowMajor)

Initialize a matrix from the specified 16 element array. The matrix may be given in row or column major form.

Parameters:
  `m` - a 16 element array in row or column major form
  `rowMajor` - `true` if the array is in row major form, `false`if it is in column major form

### Method Detail

#### isIndentity

    public final boolean isIndentity()

#### equals

    public final boolean equals(Matrix4 m)

#### asRowMajor

    public final float[] asRowMajor()

#### asColMajor

    public final float[] asColMajor()

#### determinant

    public final float determinant()

Compute the matrix determinant.

Returns:
  determinant of this matrix

#### inverse

    public final Matrix4 inverse()

Compute the inverse of this matrix and return it as a new object. If the matrix is not invertible, `null` is returned.

Returns:
  the inverse of this matrix, or `null` if not invertible

#### multiply

    public final Matrix4 multiply(Matrix4 m)

Computes this*m and return the result as a new Matrix4

Parameters:
  `m` - right hand side of the multiplication
Returns:
  a new Matrix4 object equal to `this*m`

#### transform

    public final BoundingBox transform(BoundingBox b)

Transforms each corner of the specified axis-aligned bounding box and returns a new bounding box which incloses the transformed corners.

Parameters:
  `b` - original bounding box
Returns:
  a new BoundingBox object which encloses the transform version of b

#### transformV

    public final Vector3 transformV(Vector3 v)

Computes this*v and returns the result as a new Vector3 object. This method assumes the bottom row of the matrix is `[0,0,0,1]`.

Parameters:
  `v` - vector to multiply
Returns:
  a new Vector3 object equal to `this*v`

#### transformTransposeV

    public final Vector3 transformTransposeV(Vector3 v)

Computes (this^T)*v and returns the result as a new Vector3 object. This method assumes the bottom row of the matrix is `[0,0,0,1]`.

Parameters:
  `v` - vector to multiply
Returns:
  a new Vector3 object equal to `(this^T)*v`

#### transformP

    public final Point3 transformP(Point3 p)

Computes this*p and returns the result as a new Point3 object. This method assumes the bottom row of the matrix is `[0,0,0,1]`.

Parameters:
  `p` - point to multiply
Returns:
  a new Point3 object equal to `this*v`

#### transformVX

    public final float transformVX(float x,
                    float y,
                    float z)

Computes the x component of this*(x,y,z,0).

Parameters:
  `x` - x coordinate of the vector to multiply
  `y` - y coordinate of the vector to multiply
  `z` - z coordinate of the vector to multiply
Returns:
  x coordinate transformation result

#### transformVY

    public final float transformVY(float x,
                    float y,
                    float z)

Computes the y component of this*(x,y,z,0).

Parameters:
  `x` - x coordinate of the vector to multiply
  `y` - y coordinate of the vector to multiply
  `z` - z coordinate of the vector to multiply
Returns:
  y coordinate transformation result

#### transformVZ

    public final float transformVZ(float x,
                    float y,
                    float z)

Computes the z component of this*(x,y,z,0).

Parameters:
  `x` - x coordinate of the vector to multiply
  `y` - y coordinate of the vector to multiply
  `z` - z coordinate of the vector to multiply
Returns:
  z coordinate transformation result

#### transformTransposeVX

    public final float transformTransposeVX(float x,
                             float y,
                             float z)

Computes the x component of (this^T)*(x,y,z,0).

Parameters:
  `x` - x coordinate of the vector to multiply
  `y` - y coordinate of the vector to multiply
  `z` - z coordinate of the vector to multiply
Returns:
  x coordinate transformation result

#### transformTransposeVY

    public final float transformTransposeVY(float x,
                             float y,
                             float z)

Computes the y component of (this^T)*(x,y,z,0).

Parameters:
  `x` - x coordinate of the vector to multiply
  `y` - y coordinate of the vector to multiply
  `z` - z coordinate of the vector to multiply
Returns:
  y coordinate transformation result

#### transformTransposeVZ

    public final float transformTransposeVZ(float x,
                             float y,
                             float z)

Computes the z component of (this^T)*(x,y,z,0).

Parameters:
  `x` - x coordinate of the vector to multiply
  `y` - y coordinate of the vector to multiply
  `z` - z coordinate of the vector to multiply
Returns:
  zcoordinate transformation result

#### transformPX

    public final float transformPX(float x,
                    float y,
                    float z)

Computes the x component of this*(x,y,z,1).

Parameters:
  `x` - x coordinate of the vector to multiply
  `y` - y coordinate of the vector to multiply
  `z` - z coordinate of the vector to multiply
Returns:
  x coordinate transformation result

#### transformPY

    public final float transformPY(float x,
                    float y,
                    float z)

Computes the y component of this*(x,y,z,1).

Parameters:
  `x` - x coordinate of the vector to multiply
  `y` - y coordinate of the vector to multiply
  `z` - z coordinate of the vector to multiply
Returns:
  y coordinate transformation result

#### transformPZ

    public final float transformPZ(float x,
                    float y,
                    float z)

Computes the z component of this*(x,y,z,1).

Parameters:
  `x` - x coordinate of the vector to multiply
  `y` - y coordinate of the vector to multiply
  `z` - z coordinate of the vector to multiply
Returns:
  z coordinate transformation result

#### translation

    public static final Matrix4 translation(float x,
                      float y,
                      float z)

Create a translation matrix for the specified vector.

Parameters:
  `x` - x component of translation
  `y` - y component of translation
  `z` - z component of translation
Returns:
  a new Matrix4 object representing the translation

#### rotateX

    public static final Matrix4 rotateX(float theta)

Creates a rotation matrix about the X axis.

Parameters:
  `theta` - angle to rotate about the X axis in radians
Returns:
  a new Matrix4 object representing the rotation

#### rotateY

    public static final Matrix4 rotateY(float theta)

Creates a rotation matrix about the Y axis.

Parameters:
  `theta` - angle to rotate about the Y axis in radians
Returns:
  a new Matrix4 object representing the rotation

#### rotateZ

    public static final Matrix4 rotateZ(float theta)

Creates a rotation matrix about the Z axis.

Parameters:
  `theta` - angle to rotate about the Z axis in radians
Returns:
  a new Matrix4 object representing the rotation

#### rotate

    public static final Matrix4 rotate(float x,
                 float y,
                 float z,
                 float theta)

Creates a rotation matrix about the specified axis. The axis vector need not be normalized.

Parameters:
  `x` - x component of the axis vector
  `y` - y component of the axis vector
  `z` - z component of the axis vector
  `theta` - angle to rotate about the axis in radians
Returns:
  a new Matrix4 object representing the rotation

#### scale

    public static final Matrix4 scale(float s)

Create a uniform scaling matrix.

Parameters:
  `s` - scale factor for all three axes
Returns:
  a new Matrix4 object representing the uniform scale

#### scale

    public static final Matrix4 scale(float sx,
                float sy,
                float sz)

Creates a non-uniform scaling matrix.

Parameters:
  `sx` - scale factor in the x dimension
  `sy` - scale factor in the y dimension
  `sz` - scale factor in the z dimension
Returns:
  a new Matrix4 object representing the non-uniform scale

#### fromBasis

    public static final Matrix4 fromBasis(OrthoNormalBasis basis)

Creates a rotation matrix from an OrthonormalBasis.

Parameters:
  `basis` -

#### lookAt

    public static final Matrix4 lookAt(Point3 eye,
                 Point3 target,
                 Vector3 up)

Creates a camera positioning matrix from the given eye and target points and up vector.

Parameters:
  `eye` - location of the eye
  `target` - location of the target
  `up` - vector pointing upwards
Returns:

#### blend

    public static final Matrix4 blend(Matrix4 m0,
                Matrix4 m1,
                float t)