Class 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.
    • Constructor Summary

      Constructors 
      Constructor 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

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      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, falseif 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: