Package org.joml

Class Matrix3d

  • All Implemented Interfaces:
    java.io.Externalizable, java.io.Serializable, Matrix3dc
    Direct Known Subclasses:
    Matrix3dStack

    public class Matrix3d
    extends java.lang.Object
    implements java.io.Externalizable, Matrix3dc
    Contains the definition of a 3x3 matrix of doubles, and associated functions to transform it. The matrix is column-major to match OpenGL's interpretation, and it looks like this:

    m00 m10 m20
    m01 m11 m21
    m02 m12 m22

    Author:
    Richard Greenlees, Kai Burjack
    See Also:
    Serialized Form
    • Field Summary

      Fields 
      Modifier and Type Field Description
      double m00  
      double m01  
      double m02  
      double m10  
      double m11  
      double m12  
      double m20  
      double m21  
      double m22  
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      Matrix3d _m00​(double m00)
      Set the value of the matrix element at column 0 and row 0.
      Matrix3d _m01​(double m01)
      Set the value of the matrix element at column 0 and row 1.
      Matrix3d _m02​(double m02)
      Set the value of the matrix element at column 0 and row 2.
      Matrix3d _m10​(double m10)
      Set the value of the matrix element at column 1 and row 0.
      Matrix3d _m11​(double m11)
      Set the value of the matrix element at column 1 and row 1.
      Matrix3d _m12​(double m12)
      Set the value of the matrix element at column 1 and row 2.
      Matrix3d _m20​(double m20)
      Set the value of the matrix element at column 2 and row 0.
      Matrix3d _m21​(double m21)
      Set the value of the matrix element at column 2 and row 1.
      Matrix3d _m22​(double m22)
      Set the value of the matrix element at column 2 and row 2.
      Matrix3d add​(Matrix3dc other)
      Component-wise add this and other.
      Matrix3d add​(Matrix3dc other, Matrix3d dest)
      Component-wise add this and other and store the result in dest.
      double determinant()
      Return the determinant of this matrix.
      boolean equals​(java.lang.Object obj)  
      boolean equals​(Matrix3dc m, double delta)
      Compare the matrix elements of this matrix with the given matrix using the given delta and return whether all of them are equal within a maximum difference of delta.
      double[] get​(double[] arr)
      Store this matrix into the supplied double array in column-major order.
      double[] get​(double[] arr, int offset)
      Store this matrix into the supplied double array in column-major order at the given offset.
      float[] get​(float[] arr)
      Store the elements of this matrix as float values in column-major order into the supplied float array.
      float[] get​(float[] arr, int offset)
      Store the elements of this matrix as float values in column-major order into the supplied float array at the given offset.
      double get​(int column, int row)
      Get the matrix element value at the given column and row.
      java.nio.ByteBuffer get​(int index, java.nio.ByteBuffer buffer)
      Store this matrix in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.
      java.nio.DoubleBuffer get​(int index, java.nio.DoubleBuffer buffer)
      Store this matrix into the supplied DoubleBuffer starting at the specified absolute buffer position/index using column-major order.
      java.nio.FloatBuffer get​(int index, java.nio.FloatBuffer buffer)
      Store this matrix in column-major order into the supplied FloatBuffer starting at the specified absolute buffer position/index.
      java.nio.ByteBuffer get​(java.nio.ByteBuffer buffer)
      Store this matrix in column-major order into the supplied ByteBuffer at the current buffer position.
      java.nio.DoubleBuffer get​(java.nio.DoubleBuffer buffer)
      Store this matrix into the supplied DoubleBuffer at the current buffer position using column-major order.
      java.nio.FloatBuffer get​(java.nio.FloatBuffer buffer)
      Store this matrix in column-major order into the supplied FloatBuffer at the current buffer position.
      Matrix3d get​(Matrix3d dest)
      Get the current values of this matrix and store them into dest.
      Vector3d getColumn​(int column, Vector3d dest)
      Get the column at the given column index, starting with 0.
      Vector3d getEulerAnglesZYX​(Vector3d dest)
      Extract the Euler angles from the rotation represented by this matrix and store the extracted Euler angles in dest.
      java.nio.ByteBuffer getFloats​(int index, java.nio.ByteBuffer buffer)
      Store the elements of this matrix as float values in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.
      java.nio.ByteBuffer getFloats​(java.nio.ByteBuffer buffer)
      Store the elements of this matrix as float values in column-major order into the supplied ByteBuffer at the current buffer position.
      Quaterniond getNormalizedRotation​(Quaterniond dest)
      Get the current values of this matrix and store the represented rotation into the given Quaterniond.
      Quaternionf getNormalizedRotation​(Quaternionf dest)
      Get the current values of this matrix and store the represented rotation into the given Quaternionf.
      AxisAngle4f getRotation​(AxisAngle4f dest)
      Get the current values of this matrix and store the represented rotation into the given AxisAngle4f.
      Vector3d getRow​(int row, Vector3d dest)
      Get the row at the given row index, starting with 0.
      Vector3d getScale​(Vector3d dest)
      Get the scaling factors of this matrix for the three base axes.
      Matrix3dc getToAddress​(long address)
      Store this matrix in column-major order at the given off-heap address.
      Quaterniond getUnnormalizedRotation​(Quaterniond dest)
      Get the current values of this matrix and store the represented rotation into the given Quaterniond.
      Quaternionf getUnnormalizedRotation​(Quaternionf dest)
      Get the current values of this matrix and store the represented rotation into the given Quaternionf.
      int hashCode()  
      Matrix3d identity()
      Set this matrix to the identity.
      Matrix3d invert()
      Invert this matrix.
      Matrix3d invert​(Matrix3d dest)
      Invert this matrix and store the result in dest.
      Matrix3d lerp​(Matrix3dc other, double t)
      Linearly interpolate this and other using the given interpolation factor t and store the result in this.
      Matrix3d lerp​(Matrix3dc other, double t, Matrix3d dest)
      Linearly interpolate this and other using the given interpolation factor t and store the result in dest.
      Matrix3d lookAlong​(double dirX, double dirY, double dirZ, double upX, double upY, double upZ)
      Apply a rotation transformation to this matrix to make -z point along dir.
      Matrix3d lookAlong​(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix3d dest)
      Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
      Matrix3d lookAlong​(Vector3dc dir, Vector3dc up)
      Apply a rotation transformation to this matrix to make -z point along dir.
      Matrix3d lookAlong​(Vector3dc dir, Vector3dc up, Matrix3d dest)
      Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
      double m00()
      Return the value of the matrix element at column 0 and row 0.
      Matrix3d m00​(double m00)
      Set the value of the matrix element at column 0 and row 0.
      double m01()
      Return the value of the matrix element at column 0 and row 1.
      Matrix3d m01​(double m01)
      Set the value of the matrix element at column 0 and row 1.
      double m02()
      Return the value of the matrix element at column 0 and row 2.
      Matrix3d m02​(double m02)
      Set the value of the matrix element at column 0 and row 2.
      double m10()
      Return the value of the matrix element at column 1 and row 0.
      Matrix3d m10​(double m10)
      Set the value of the matrix element at column 1 and row 0.
      double m11()
      Return the value of the matrix element at column 1 and row 1.
      Matrix3d m11​(double m11)
      Set the value of the matrix element at column 1 and row 1.
      double m12()
      Return the value of the matrix element at column 1 and row 2.
      Matrix3d m12​(double m12)
      Set the value of the matrix element at column 1 and row 2.
      double m20()
      Return the value of the matrix element at column 2 and row 0.
      Matrix3d m20​(double m20)
      Set the value of the matrix element at column 2 and row 0.
      double m21()
      Return the value of the matrix element at column 2 and row 1.
      Matrix3d m21​(double m21)
      Set the value of the matrix element at column 2 and row 1.
      double m22()
      Return the value of the matrix element at column 2 and row 2.
      Matrix3d m22​(double m22)
      Set the value of the matrix element at column 2 and row 2.
      Matrix3d mul​(Matrix3dc right)
      Multiply this matrix by the supplied matrix.
      Matrix3d mul​(Matrix3dc right, Matrix3d dest)
      Multiply this matrix by the supplied matrix and store the result in dest.
      Matrix3d mul​(Matrix3fc right)
      Multiply this matrix by the supplied matrix.
      Matrix3d mul​(Matrix3fc right, Matrix3d dest)
      Multiply this matrix by the supplied matrix and store the result in dest.
      Matrix3d mulComponentWise​(Matrix3dc other)
      Component-wise multiply this by other.
      Matrix3d mulComponentWise​(Matrix3dc other, Matrix3d dest)
      Component-wise multiply this by other and store the result in dest.
      Matrix3d mulLocal​(Matrix3dc left)
      Pre-multiply this matrix by the supplied left matrix and store the result in this.
      Matrix3d mulLocal​(Matrix3dc left, Matrix3d dest)
      Pre-multiply this matrix by the supplied left matrix and store the result in dest.
      Matrix3d normal()
      Set this matrix to its own normal matrix.
      Matrix3d normal​(Matrix3d dest)
      Compute a normal matrix from this matrix and store it into dest.
      Vector3d normalizedPositiveX​(Vector3d dir)
      Obtain the direction of +X before the transformation represented by this orthogonal matrix is applied.
      Vector3d normalizedPositiveY​(Vector3d dir)
      Obtain the direction of +Y before the transformation represented by this orthogonal matrix is applied.
      Vector3d normalizedPositiveZ​(Vector3d dir)
      Obtain the direction of +Z before the transformation represented by this orthogonal matrix is applied.
      Matrix3d obliqueZ​(double a, double b)
      Apply an oblique projection transformation to this matrix with the given values for a and b.
      Matrix3d obliqueZ​(double a, double b, Matrix3d dest)
      Apply an oblique projection transformation to this matrix with the given values for a and b and store the result in dest.
      Vector3d positiveX​(Vector3d dir)
      Obtain the direction of +X before the transformation represented by this matrix is applied.
      Vector3d positiveY​(Vector3d dir)
      Obtain the direction of +Y before the transformation represented by this matrix is applied.
      Vector3d positiveZ​(Vector3d dir)
      Obtain the direction of +Z before the transformation represented by this matrix is applied.
      void readExternal​(java.io.ObjectInput in)  
      Matrix3d rotate​(double ang, double x, double y, double z)
      Apply rotation to this matrix by rotating the given amount of radians about the given axis specified as x, y and z components.
      Matrix3d rotate​(double ang, double x, double y, double z, Matrix3d dest)
      Apply rotation to this matrix by rotating the given amount of radians about the given axis specified as x, y and z components, and store the result in dest.
      Matrix3d rotate​(double angle, Vector3dc axis)
      Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
      Matrix3d rotate​(double angle, Vector3dc axis, Matrix3d dest)
      Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
      Matrix3d rotate​(double angle, Vector3fc axis)
      Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
      Matrix3d rotate​(double angle, Vector3fc axis, Matrix3d dest)
      Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
      Matrix3d rotate​(AxisAngle4d axisAngle)
      Apply a rotation transformation, rotating about the given AxisAngle4d, to this matrix.
      Matrix3d rotate​(AxisAngle4d axisAngle, Matrix3d dest)
      Apply a rotation transformation, rotating about the given AxisAngle4d and store the result in dest.
      Matrix3d rotate​(AxisAngle4f axisAngle)
      Apply a rotation transformation, rotating about the given AxisAngle4f, to this matrix.
      Matrix3d rotate​(AxisAngle4f axisAngle, Matrix3d dest)
      Apply a rotation transformation, rotating about the given AxisAngle4f and store the result in dest.
      Matrix3d rotate​(Quaterniondc quat)
      Apply the rotation - and possibly scaling - transformation of the given Quaterniondc to this matrix.
      Matrix3d rotate​(Quaterniondc quat, Matrix3d dest)
      Apply the rotation - and possibly scaling - transformation of the given Quaterniondc to this matrix and store the result in dest.
      Matrix3d rotate​(Quaternionfc quat)
      Apply the rotation - and possibly scaling - transformation of the given Quaternionfc to this matrix.
      Matrix3d rotate​(Quaternionfc quat, Matrix3d dest)
      Apply the rotation - and possibly scaling - transformation of the given Quaternionfc to this matrix and store the result in dest.
      Matrix3d rotateLocal​(double ang, double x, double y, double z)
      Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified (x, y, z) axis.
      Matrix3d rotateLocal​(double ang, double x, double y, double z, Matrix3d dest)
      Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified (x, y, z) axis and store the result in dest.
      Matrix3d rotateLocal​(Quaterniondc quat)
      Pre-multiply the rotation - and possibly scaling - transformation of the given Quaterniondc to this matrix.
      Matrix3d rotateLocal​(Quaterniondc quat, Matrix3d dest)
      Pre-multiply the rotation - and possibly scaling - transformation of the given Quaterniondc to this matrix and store the result in dest.
      Matrix3d rotateLocal​(Quaternionfc quat)
      Pre-multiply the rotation - and possibly scaling - transformation of the given Quaternionfc to this matrix.
      Matrix3d rotateLocal​(Quaternionfc quat, Matrix3d dest)
      Pre-multiply the rotation - and possibly scaling - transformation of the given Quaternionfc to this matrix and store the result in dest.
      Matrix3d rotateLocalX​(double ang)
      Pre-multiply a rotation to this matrix by rotating the given amount of radians about the X axis.
      Matrix3d rotateLocalX​(double ang, Matrix3d dest)
      Pre-multiply a rotation around the X axis to this matrix by rotating the given amount of radians about the X axis and store the result in dest.
      Matrix3d rotateLocalY​(double ang)
      Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Y axis.
      Matrix3d rotateLocalY​(double ang, Matrix3d dest)
      Pre-multiply a rotation around the Y axis to this matrix by rotating the given amount of radians about the Y axis and store the result in dest.
      Matrix3d rotateLocalZ​(double ang)
      Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Z axis.
      Matrix3d rotateLocalZ​(double ang, Matrix3d dest)
      Pre-multiply a rotation around the Z axis to this matrix by rotating the given amount of radians about the Z axis and store the result in dest.
      Matrix3d rotateTowards​(double dirX, double dirY, double dirZ, double upX, double upY, double upZ)
      Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction.
      Matrix3d rotateTowards​(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix3d dest)
      Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with dir and store the result in dest.
      Matrix3d rotateTowards​(Vector3dc direction, Vector3dc up)
      Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction.
      Matrix3d rotateTowards​(Vector3dc direction, Vector3dc up, Matrix3d dest)
      Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction and store the result in dest.
      Matrix3d rotateX​(double ang)
      Apply rotation about the X axis to this matrix by rotating the given amount of radians.
      Matrix3d rotateX​(double ang, Matrix3d dest)
      Apply rotation about the X axis to this matrix by rotating the given amount of radians and store the result in dest.
      Matrix3d rotateXYZ​(double angleX, double angleY, double angleZ)
      Apply rotation of angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis.
      Matrix3d rotateXYZ​(double angleX, double angleY, double angleZ, Matrix3d dest)
      Apply rotation of angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis and store the result in dest.
      Matrix3d rotateY​(double ang)
      Apply rotation about the Y axis to this matrix by rotating the given amount of radians.
      Matrix3d rotateY​(double ang, Matrix3d dest)
      Apply rotation about the Y axis to this matrix by rotating the given amount of radians and store the result in dest.
      Matrix3d rotateYXZ​(double angleY, double angleX, double angleZ)
      Apply rotation of angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis.
      Matrix3d rotateYXZ​(double angleY, double angleX, double angleZ, Matrix3d dest)
      Apply rotation of angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis and store the result in dest.
      Matrix3d rotateYXZ​(Vector3d angles)
      Apply rotation of angles.y radians about the Y axis, followed by a rotation of angles.x radians about the X axis and followed by a rotation of angles.z radians about the Z axis.
      Matrix3d rotateZ​(double ang)
      Apply rotation about the Z axis to this matrix by rotating the given amount of radians.
      Matrix3d rotateZ​(double ang, Matrix3d dest)
      Apply rotation about the Z axis to this matrix by rotating the given amount of radians and store the result in dest.
      Matrix3d rotateZYX​(double angleZ, double angleY, double angleX)
      Apply rotation of angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis.
      Matrix3d rotateZYX​(double angleZ, double angleY, double angleX, Matrix3d dest)
      Apply rotation of angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis and store the result in dest.
      Matrix3d rotation​(double angle, double x, double y, double z)
      Set this matrix to a rotation matrix which rotates the given radians about a given axis.
      Matrix3d rotation​(double angle, Vector3dc axis)
      Set this matrix to a rotation matrix which rotates the given radians about a given axis.
      Matrix3d rotation​(double angle, Vector3fc axis)
      Set this matrix to a rotation matrix which rotates the given radians about a given axis.
      Matrix3d rotation​(AxisAngle4d axisAngle)
      Set this matrix to a rotation transformation using the given AxisAngle4d.
      Matrix3d rotation​(AxisAngle4f axisAngle)
      Set this matrix to a rotation transformation using the given AxisAngle4f.
      Matrix3d rotation​(Quaterniondc quat)
      Set this matrix to the rotation - and possibly scaling - transformation of the given Quaterniondc.
      Matrix3d rotation​(Quaternionfc quat)
      Set this matrix to the rotation - and possibly scaling - transformation of the given Quaternionfc.
      Matrix3d rotationTowards​(double dirX, double dirY, double dirZ, double upX, double upY, double upZ)
      Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local -z axis with center - eye.
      Matrix3d rotationTowards​(Vector3dc dir, Vector3dc up)
      Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local -z axis with center - eye.
      Matrix3d rotationX​(double ang)
      Set this matrix to a rotation transformation about the X axis.
      Matrix3d rotationXYZ​(double angleX, double angleY, double angleZ)
      Set this matrix to a rotation of angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis.
      Matrix3d rotationY​(double ang)
      Set this matrix to a rotation transformation about the Y axis.
      Matrix3d rotationYXZ​(double angleY, double angleX, double angleZ)
      Set this matrix to a rotation of angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis.
      Matrix3d rotationZ​(double ang)
      Set this matrix to a rotation transformation about the Z axis.
      Matrix3d rotationZYX​(double angleZ, double angleY, double angleX)
      Set this matrix to a rotation of angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis.
      Matrix3d scale​(double xyz)
      Apply scaling to this matrix by uniformly scaling all base axes by the given xyz factor.
      Matrix3d scale​(double x, double y, double z)
      Apply scaling to this matrix by scaling the base axes by the given x, y and z factors.
      Matrix3d scale​(double x, double y, double z, Matrix3d dest)
      Apply scaling to this matrix by scaling the base axes by the given x, y and z factors and store the result in dest.
      Matrix3d scale​(double xyz, Matrix3d dest)
      Apply scaling to this matrix by uniformly scaling all base axes by the given xyz factor and store the result in dest.
      Matrix3d scale​(Vector3dc xyz)
      Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively.
      Matrix3d scale​(Vector3dc xyz, Matrix3d dest)
      Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively and store the result in dest.
      Matrix3d scaleLocal​(double x, double y, double z)
      Pre-multiply scaling to this matrix by scaling the base axes by the given x, y and z factors.
      Matrix3d scaleLocal​(double x, double y, double z, Matrix3d dest)
      Pre-multiply scaling to this matrix by scaling the base axes by the given x, y and z factors and store the result in dest.
      Matrix3d scaling​(double factor)
      Set this matrix to be a simple scale matrix, which scales all axes uniformly by the given factor.
      Matrix3d scaling​(double x, double y, double z)
      Set this matrix to be a simple scale matrix.
      Matrix3d scaling​(Vector3dc xyz)
      Set this matrix to be a simple scale matrix which scales the base axes by xyz.x, xyz.y and xyz.z respectively.
      Matrix3d set​(double[] m)
      Set the values in this matrix based on the supplied double array.
      Matrix3d set​(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22)
      Set the values within this matrix to the supplied double values.
      Matrix3d set​(float[] m)
      Set the values in this matrix based on the supplied double array.
      Matrix3d set​(int column, int row, double value)
      Set the matrix element at the given column and row to the specified value.
      Matrix3d set​(java.nio.ByteBuffer buffer)
      Set the values of this matrix by reading 9 double values from the given ByteBuffer in column-major order, starting at its current position.
      Matrix3d set​(java.nio.DoubleBuffer buffer)
      Set the values of this matrix by reading 9 double values from the given DoubleBuffer in column-major order, starting at its current position.
      Matrix3d set​(java.nio.FloatBuffer buffer)
      Set the values of this matrix by reading 9 float values from the given FloatBuffer in column-major order, starting at its current position.
      Matrix3d set​(AxisAngle4d axisAngle)
      Set this matrix to be equivalent to the rotation specified by the given AxisAngle4d.
      Matrix3d set​(AxisAngle4f axisAngle)
      Set this matrix to be equivalent to the rotation specified by the given AxisAngle4f.
      Matrix3d set​(Matrix3dc m)
      Set the values in this matrix to the ones in m.
      Matrix3d set​(Matrix3fc m)
      Set the values in this matrix to the ones in m.
      Matrix3d set​(Matrix4dc mat)
      Set the elements of this matrix to the upper left 3x3 of the given Matrix4dc.
      Matrix3d set​(Matrix4fc mat)
      Set the elements of this matrix to the upper left 3x3 of the given Matrix4fc.
      Matrix3d set​(Matrix4x3dc m)
      Set the elements of this matrix to the left 3x3 submatrix of m.
      Matrix3d set​(Quaterniondc q)
      Set this matrix to a rotation - and possibly scaling - equivalent to the given quaternion.
      Matrix3d set​(Quaternionfc q)
      Set this matrix to a rotation - and possibly scaling - equivalent to the given quaternion.
      Matrix3d set​(Vector3dc col0, Vector3dc col1, Vector3dc col2)
      Set the three columns of this matrix to the supplied vectors, respectively.
      Matrix3d setColumn​(int column, double x, double y, double z)
      Set the column at the given column index, starting with 0.
      Matrix3d setColumn​(int column, Vector3dc src)
      Set the column at the given column index, starting with 0.
      Matrix3d setFloats​(java.nio.ByteBuffer buffer)
      Set the values of this matrix by reading 9 float values from the given ByteBuffer in column-major order, starting at its current position.
      Matrix3d setFromAddress​(long address)
      Set the values of this matrix by reading 9 double values from off-heap memory in column-major order, starting at the given address.
      Matrix3d setLookAlong​(double dirX, double dirY, double dirZ, double upX, double upY, double upZ)
      Set this matrix to a rotation transformation to make -z point along dir.
      Matrix3d setLookAlong​(Vector3dc dir, Vector3dc up)
      Set this matrix to a rotation transformation to make -z point along dir.
      Matrix3d setRow​(int row, double x, double y, double z)
      Set the row at the given row index, starting with 0.
      Matrix3d setRow​(int row, Vector3dc src)
      Set the row at the given row index, starting with 0.
      Matrix3d setSkewSymmetric​(double a, double b, double c)
      Set this matrix to a skew-symmetric matrix using the following layout:
      Matrix3d sub​(Matrix3dc subtrahend)
      Component-wise subtract subtrahend from this.
      Matrix3d sub​(Matrix3dc subtrahend, Matrix3d dest)
      Component-wise subtract subtrahend from this and store the result in dest.
      Matrix3d swap​(Matrix3d other)
      Exchange the values of this matrix with the given other matrix.
      java.lang.String toString()
      Return a string representation of this matrix.
      java.lang.String toString​(java.text.NumberFormat formatter)
      Return a string representation of this matrix by formatting the matrix elements with the given NumberFormat.
      Vector3d transform​(double x, double y, double z, Vector3d dest)
      Transform the vector (x, y, z) by this matrix and store the result in dest.
      Vector3d transform​(Vector3d v)
      Transform the given vector by this matrix.
      Vector3d transform​(Vector3dc v, Vector3d dest)
      Transform the given vector by this matrix and store the result in dest.
      Vector3f transform​(Vector3f v)
      Transform the given vector by this matrix.
      Vector3f transform​(Vector3fc v, Vector3f dest)
      Transform the given vector by this matrix and store the result in dest.
      Vector3d transformTranspose​(double x, double y, double z, Vector3d dest)
      Transform the vector (x, y, z) by the transpose of this matrix and store the result in dest.
      Vector3d transformTranspose​(Vector3d v)
      Transform the given vector by the transpose of this matrix.
      Vector3d transformTranspose​(Vector3dc v, Vector3d dest)
      Transform the given vector by the transpose of this matrix and store the result in dest.
      Matrix3d transpose()
      Transpose this matrix.
      Matrix3d transpose​(Matrix3d dest)
      Transpose this matrix and store the result in dest.
      void writeExternal​(java.io.ObjectOutput out)  
      Matrix3d zero()
      Set all the values within this matrix to 0.
      • Methods inherited from class java.lang.Object

        clone, finalize, getClass, notify, notifyAll, wait, wait, wait
    • Field Detail

      • m00

        public double m00
      • m01

        public double m01
      • m02

        public double m02
      • m10

        public double m10
      • m11

        public double m11
      • m12

        public double m12
      • m20

        public double m20
      • m21

        public double m21
      • m22

        public double m22
    • Constructor Detail

      • Matrix3d

        public Matrix3d()
        Create a new Matrix3d and initialize it to identity.
      • Matrix3d

        public Matrix3d​(Matrix3dc mat)
        Create a new Matrix3d and initialize it with the values from the given matrix.
        Parameters:
        mat - the matrix to initialize this matrix with
      • Matrix3d

        public Matrix3d​(Matrix3fc mat)
        Create a new Matrix3d and initialize it with the values from the given matrix.
        Parameters:
        mat - the matrix to initialize this matrix with
      • Matrix3d

        public Matrix3d​(Matrix4fc mat)
        Create a new Matrix3d and make it a copy of the upper left 3x3 of the given Matrix4fc.
        Parameters:
        mat - the Matrix4fc to copy the values from
      • Matrix3d

        public Matrix3d​(Matrix4dc mat)
        Create a new Matrix3d and make it a copy of the upper left 3x3 of the given Matrix4dc.
        Parameters:
        mat - the Matrix4dc to copy the values from
      • Matrix3d

        public Matrix3d​(double m00,
                        double m01,
                        double m02,
                        double m10,
                        double m11,
                        double m12,
                        double m20,
                        double m21,
                        double m22)
        Create a new Matrix3d and initialize its elements with the given values.
        Parameters:
        m00 - the value of m00
        m01 - the value of m01
        m02 - the value of m02
        m10 - the value of m10
        m11 - the value of m11
        m12 - the value of m12
        m20 - the value of m20
        m21 - the value of m21
        m22 - the value of m22
      • Matrix3d

        public Matrix3d​(java.nio.DoubleBuffer buffer)
        Create a new Matrix3d by reading its 9 double components from the given DoubleBuffer at the buffer's current position.

        That DoubleBuffer is expected to hold the values in column-major order.

        The buffer's position will not be changed by this method.

        Parameters:
        buffer - the DoubleBuffer to read the matrix values from
      • Matrix3d

        public Matrix3d​(Vector3dc col0,
                        Vector3dc col1,
                        Vector3dc col2)
        Create a new Matrix3d and initialize its three columns using the supplied vectors.
        Parameters:
        col0 - the first column
        col1 - the second column
        col2 - the third column
    • Method Detail

      • m00

        public double m00()
        Description copied from interface: Matrix3dc
        Return the value of the matrix element at column 0 and row 0.
        Specified by:
        m00 in interface Matrix3dc
        Returns:
        the value of the matrix element
      • m01

        public double m01()
        Description copied from interface: Matrix3dc
        Return the value of the matrix element at column 0 and row 1.
        Specified by:
        m01 in interface Matrix3dc
        Returns:
        the value of the matrix element
      • m02

        public double m02()
        Description copied from interface: Matrix3dc
        Return the value of the matrix element at column 0 and row 2.
        Specified by:
        m02 in interface Matrix3dc
        Returns:
        the value of the matrix element
      • m10

        public double m10()
        Description copied from interface: Matrix3dc
        Return the value of the matrix element at column 1 and row 0.
        Specified by:
        m10 in interface Matrix3dc
        Returns:
        the value of the matrix element
      • m11

        public double m11()
        Description copied from interface: Matrix3dc
        Return the value of the matrix element at column 1 and row 1.
        Specified by:
        m11 in interface Matrix3dc
        Returns:
        the value of the matrix element
      • m12

        public double m12()
        Description copied from interface: Matrix3dc
        Return the value of the matrix element at column 1 and row 2.
        Specified by:
        m12 in interface Matrix3dc
        Returns:
        the value of the matrix element
      • m20

        public double m20()
        Description copied from interface: Matrix3dc
        Return the value of the matrix element at column 2 and row 0.
        Specified by:
        m20 in interface Matrix3dc
        Returns:
        the value of the matrix element
      • m21

        public double m21()
        Description copied from interface: Matrix3dc
        Return the value of the matrix element at column 2 and row 1.
        Specified by:
        m21 in interface Matrix3dc
        Returns:
        the value of the matrix element
      • m22

        public double m22()
        Description copied from interface: Matrix3dc
        Return the value of the matrix element at column 2 and row 2.
        Specified by:
        m22 in interface Matrix3dc
        Returns:
        the value of the matrix element
      • m00

        public Matrix3d m00​(double m00)
        Set the value of the matrix element at column 0 and row 0.
        Parameters:
        m00 - the new value
        Returns:
        this
      • m01

        public Matrix3d m01​(double m01)
        Set the value of the matrix element at column 0 and row 1.
        Parameters:
        m01 - the new value
        Returns:
        this
      • m02

        public Matrix3d m02​(double m02)
        Set the value of the matrix element at column 0 and row 2.
        Parameters:
        m02 - the new value
        Returns:
        this
      • m10

        public Matrix3d m10​(double m10)
        Set the value of the matrix element at column 1 and row 0.
        Parameters:
        m10 - the new value
        Returns:
        this
      • m11

        public Matrix3d m11​(double m11)
        Set the value of the matrix element at column 1 and row 1.
        Parameters:
        m11 - the new value
        Returns:
        this
      • m12

        public Matrix3d m12​(double m12)
        Set the value of the matrix element at column 1 and row 2.
        Parameters:
        m12 - the new value
        Returns:
        this
      • m20

        public Matrix3d m20​(double m20)
        Set the value of the matrix element at column 2 and row 0.
        Parameters:
        m20 - the new value
        Returns:
        this
      • m21

        public Matrix3d m21​(double m21)
        Set the value of the matrix element at column 2 and row 1.
        Parameters:
        m21 - the new value
        Returns:
        this
      • m22

        public Matrix3d m22​(double m22)
        Set the value of the matrix element at column 2 and row 2.
        Parameters:
        m22 - the new value
        Returns:
        this
      • _m00

        public Matrix3d _m00​(double m00)
        Set the value of the matrix element at column 0 and row 0.
        Parameters:
        m00 - the new value
        Returns:
        this
      • _m01

        public Matrix3d _m01​(double m01)
        Set the value of the matrix element at column 0 and row 1.
        Parameters:
        m01 - the new value
        Returns:
        this
      • _m02

        public Matrix3d _m02​(double m02)
        Set the value of the matrix element at column 0 and row 2.
        Parameters:
        m02 - the new value
        Returns:
        this
      • _m10

        public Matrix3d _m10​(double m10)
        Set the value of the matrix element at column 1 and row 0.
        Parameters:
        m10 - the new value
        Returns:
        this
      • _m11

        public Matrix3d _m11​(double m11)
        Set the value of the matrix element at column 1 and row 1.
        Parameters:
        m11 - the new value
        Returns:
        this
      • _m12

        public Matrix3d _m12​(double m12)
        Set the value of the matrix element at column 1 and row 2.
        Parameters:
        m12 - the new value
        Returns:
        this
      • _m20

        public Matrix3d _m20​(double m20)
        Set the value of the matrix element at column 2 and row 0.
        Parameters:
        m20 - the new value
        Returns:
        this
      • _m21

        public Matrix3d _m21​(double m21)
        Set the value of the matrix element at column 2 and row 1.
        Parameters:
        m21 - the new value
        Returns:
        this
      • _m22

        public Matrix3d _m22​(double m22)
        Set the value of the matrix element at column 2 and row 2.
        Parameters:
        m22 - the new value
        Returns:
        this
      • set

        public Matrix3d set​(Matrix3dc m)
        Set the values in this matrix to the ones in m.
        Parameters:
        m - the matrix whose values will be copied
        Returns:
        this
      • set

        public Matrix3d set​(Matrix3fc m)
        Set the values in this matrix to the ones in m.
        Parameters:
        m - the matrix whose values will be copied
        Returns:
        this
      • set

        public Matrix3d set​(Matrix4x3dc m)
        Set the elements of this matrix to the left 3x3 submatrix of m.
        Parameters:
        m - the matrix to copy the elements from
        Returns:
        this
      • set

        public Matrix3d set​(Matrix4fc mat)
        Set the elements of this matrix to the upper left 3x3 of the given Matrix4fc.
        Parameters:
        mat - the Matrix4fc to copy the values from
        Returns:
        this
      • set

        public Matrix3d set​(Matrix4dc mat)
        Set the elements of this matrix to the upper left 3x3 of the given Matrix4dc.
        Parameters:
        mat - the Matrix4dc to copy the values from
        Returns:
        this
      • mul

        public Matrix3d mul​(Matrix3dc right)
        Multiply this matrix by the supplied matrix. This matrix will be the left one.

        If M is this matrix and R the right matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the transformation of the right matrix will be applied first!

        Parameters:
        right - the right operand
        Returns:
        this
      • mul

        public Matrix3d mul​(Matrix3dc right,
                            Matrix3d dest)
        Description copied from interface: Matrix3dc
        Multiply this matrix by the supplied matrix and store the result in dest. This matrix will be the left one.

        If M is this matrix and R the right matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the transformation of the right matrix will be applied first!

        Specified by:
        mul in interface Matrix3dc
        Parameters:
        right - the right operand
        dest - will hold the result
        Returns:
        dest
      • mulLocal

        public Matrix3d mulLocal​(Matrix3dc left)
        Pre-multiply this matrix by the supplied left matrix and store the result in this.

        If M is this matrix and L the left matrix, then the new matrix will be L * M. So when transforming a vector v with the new matrix by using L * M * v, the transformation of this matrix will be applied first!

        Parameters:
        left - the left operand of the matrix multiplication
        Returns:
        this
      • mulLocal

        public Matrix3d mulLocal​(Matrix3dc left,
                                 Matrix3d dest)
        Description copied from interface: Matrix3dc
        Pre-multiply this matrix by the supplied left matrix and store the result in dest.

        If M is this matrix and L the left matrix, then the new matrix will be L * M. So when transforming a vector v with the new matrix by using L * M * v, the transformation of this matrix will be applied first!

        Specified by:
        mulLocal in interface Matrix3dc
        Parameters:
        left - the left operand of the matrix multiplication
        dest - the destination matrix, which will hold the result
        Returns:
        dest
      • mul

        public Matrix3d mul​(Matrix3fc right)
        Multiply this matrix by the supplied matrix. This matrix will be the left one.

        If M is this matrix and R the right matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the transformation of the right matrix will be applied first!

        Parameters:
        right - the right operand
        Returns:
        this
      • mul

        public Matrix3d mul​(Matrix3fc right,
                            Matrix3d dest)
        Description copied from interface: Matrix3dc
        Multiply this matrix by the supplied matrix and store the result in dest. This matrix will be the left one.

        If M is this matrix and R the right matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the transformation of the right matrix will be applied first!

        Specified by:
        mul in interface Matrix3dc
        Parameters:
        right - the right operand
        dest - will hold the result
        Returns:
        dest
      • set

        public Matrix3d set​(double m00,
                            double m01,
                            double m02,
                            double m10,
                            double m11,
                            double m12,
                            double m20,
                            double m21,
                            double m22)
        Set the values within this matrix to the supplied double values. The result looks like this:

        m00, m10, m20
        m01, m11, m21
        m02, m12, m22

        Parameters:
        m00 - the new value of m00
        m01 - the new value of m01
        m02 - the new value of m02
        m10 - the new value of m10
        m11 - the new value of m11
        m12 - the new value of m12
        m20 - the new value of m20
        m21 - the new value of m21
        m22 - the new value of m22
        Returns:
        this
      • set

        public Matrix3d set​(double[] m)
        Set the values in this matrix based on the supplied double array. The result looks like this:

        0, 3, 6
        1, 4, 7
        2, 5, 8

        Only uses the first 9 values, all others are ignored.

        Parameters:
        m - the array to read the matrix values from
        Returns:
        this
      • set

        public Matrix3d set​(float[] m)
        Set the values in this matrix based on the supplied double array. The result looks like this:

        0, 3, 6
        1, 4, 7
        2, 5, 8

        Only uses the first 9 values, all others are ignored

        Parameters:
        m - the array to read the matrix values from
        Returns:
        this
      • determinant

        public double determinant()
        Description copied from interface: Matrix3dc
        Return the determinant of this matrix.
        Specified by:
        determinant in interface Matrix3dc
        Returns:
        the determinant
      • invert

        public Matrix3d invert()
        Invert this matrix.
        Returns:
        this
      • invert

        public Matrix3d invert​(Matrix3d dest)
        Description copied from interface: Matrix3dc
        Invert this matrix and store the result in dest.
        Specified by:
        invert in interface Matrix3dc
        Parameters:
        dest - will hold the result
        Returns:
        dest
      • transpose

        public Matrix3d transpose()
        Transpose this matrix.
        Returns:
        this
      • transpose

        public Matrix3d transpose​(Matrix3d dest)
        Description copied from interface: Matrix3dc
        Transpose this matrix and store the result in dest.
        Specified by:
        transpose in interface Matrix3dc
        Parameters:
        dest - will hold the result
        Returns:
        dest
      • toString

        public java.lang.String toString()
        Return a string representation of this matrix.

        This method creates a new DecimalFormat on every invocation with the format string "0.000E0;-".

        Overrides:
        toString in class java.lang.Object
        Returns:
        the string representation
      • toString

        public java.lang.String toString​(java.text.NumberFormat formatter)
        Return a string representation of this matrix by formatting the matrix elements with the given NumberFormat.
        Parameters:
        formatter - the NumberFormat used to format the matrix values with
        Returns:
        the string representation
      • get

        public Matrix3d get​(Matrix3d dest)
        Get the current values of this matrix and store them into dest.

        This is the reverse method of set(Matrix3dc) and allows to obtain intermediate calculation results when chaining multiple transformations.

        Specified by:
        get in interface Matrix3dc
        Parameters:
        dest - the destination matrix
        Returns:
        the passed in destination
        See Also:
        set(Matrix3dc)
      • get

        public java.nio.DoubleBuffer get​(java.nio.DoubleBuffer buffer)
        Description copied from interface: Matrix3dc
        Store this matrix into the supplied DoubleBuffer at the current buffer position using column-major order.

        This method will not increment the position of the given DoubleBuffer.

        In order to specify the offset into the DoubleBuffer} at which the matrix is stored, use Matrix3dc.get(int, DoubleBuffer), taking the absolute position as parameter.

        Specified by:
        get in interface Matrix3dc
        Parameters:
        buffer - will receive the values of this matrix in column-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        Matrix3dc.get(int, DoubleBuffer)
      • get

        public java.nio.DoubleBuffer get​(int index,
                                         java.nio.DoubleBuffer buffer)
        Description copied from interface: Matrix3dc
        Store this matrix into the supplied DoubleBuffer starting at the specified absolute buffer position/index using column-major order.

        This method will not increment the position of the given DoubleBuffer.

        Specified by:
        get in interface Matrix3dc
        Parameters:
        index - the absolute position into the DoubleBuffer
        buffer - will receive the values of this matrix in column-major order
        Returns:
        the passed in buffer
      • get

        public java.nio.FloatBuffer get​(java.nio.FloatBuffer buffer)
        Description copied from interface: Matrix3dc
        Store this matrix in column-major order into the supplied FloatBuffer at the current buffer position.

        This method will not increment the position of the given FloatBuffer.

        In order to specify the offset into the FloatBuffer at which the matrix is stored, use Matrix3dc.get(int, FloatBuffer), taking the absolute position as parameter.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given FloatBuffer.

        Specified by:
        get in interface Matrix3dc
        Parameters:
        buffer - will receive the values of this matrix in column-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        Matrix3dc.get(int, FloatBuffer)
      • get

        public java.nio.FloatBuffer get​(int index,
                                        java.nio.FloatBuffer buffer)
        Description copied from interface: Matrix3dc
        Store this matrix in column-major order into the supplied FloatBuffer starting at the specified absolute buffer position/index.

        This method will not increment the position of the given FloatBuffer.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given FloatBuffer.

        Specified by:
        get in interface Matrix3dc
        Parameters:
        index - the absolute position into the FloatBuffer
        buffer - will receive the values of this matrix in column-major order
        Returns:
        the passed in buffer
      • get

        public java.nio.ByteBuffer get​(java.nio.ByteBuffer buffer)
        Description copied from interface: Matrix3dc
        Store this matrix in column-major order into the supplied ByteBuffer at the current buffer position.

        This method will not increment the position of the given ByteBuffer.

        In order to specify the offset into the ByteBuffer at which the matrix is stored, use Matrix3dc.get(int, ByteBuffer), taking the absolute position as parameter.

        Specified by:
        get in interface Matrix3dc
        Parameters:
        buffer - will receive the values of this matrix in column-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        Matrix3dc.get(int, ByteBuffer)
      • get

        public java.nio.ByteBuffer get​(int index,
                                       java.nio.ByteBuffer buffer)
        Description copied from interface: Matrix3dc
        Store this matrix in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.

        This method will not increment the position of the given ByteBuffer.

        Specified by:
        get in interface Matrix3dc
        Parameters:
        index - the absolute position into the ByteBuffer
        buffer - will receive the values of this matrix in column-major order
        Returns:
        the passed in buffer
      • getFloats

        public java.nio.ByteBuffer getFloats​(java.nio.ByteBuffer buffer)
        Description copied from interface: Matrix3dc
        Store the elements of this matrix as float values in column-major order into the supplied ByteBuffer at the current buffer position.

        This method will not increment the position of the given ByteBuffer.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given ByteBuffer.

        In order to specify the offset into the ByteBuffer at which the matrix is stored, use Matrix3dc.getFloats(int, ByteBuffer), taking the absolute position as parameter.

        Specified by:
        getFloats in interface Matrix3dc
        Parameters:
        buffer - will receive the elements of this matrix as float values in column-major order at its current position
        Returns:
        the passed in buffer
        See Also:
        Matrix3dc.getFloats(int, ByteBuffer)
      • getFloats

        public java.nio.ByteBuffer getFloats​(int index,
                                             java.nio.ByteBuffer buffer)
        Description copied from interface: Matrix3dc
        Store the elements of this matrix as float values in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.

        This method will not increment the position of the given ByteBuffer.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given ByteBuffer.

        Specified by:
        getFloats in interface Matrix3dc
        Parameters:
        index - the absolute position into the ByteBuffer
        buffer - will receive the elements of this matrix as float values in column-major order
        Returns:
        the passed in buffer
      • getToAddress

        public Matrix3dc getToAddress​(long address)
        Description copied from interface: Matrix3dc
        Store this matrix in column-major order at the given off-heap address.

        This method will throw an UnsupportedOperationException when JOML is used with `-Djoml.nounsafe`.

        This method is unsafe as it can result in a crash of the JVM process when the specified address range does not belong to this process.

        Specified by:
        getToAddress in interface Matrix3dc
        Parameters:
        address - the off-heap address where to store this matrix
        Returns:
        this
      • get

        public double[] get​(double[] arr,
                            int offset)
        Description copied from interface: Matrix3dc
        Store this matrix into the supplied double array in column-major order at the given offset.
        Specified by:
        get in interface Matrix3dc
        Parameters:
        arr - the array to write the matrix values into
        offset - the offset into the array
        Returns:
        the passed in array
      • get

        public double[] get​(double[] arr)
        Description copied from interface: Matrix3dc
        Store this matrix into the supplied double array in column-major order.

        In order to specify an explicit offset into the array, use the method Matrix3dc.get(double[], int).

        Specified by:
        get in interface Matrix3dc
        Parameters:
        arr - the array to write the matrix values into
        Returns:
        the passed in array
        See Also:
        Matrix3dc.get(double[], int)
      • get

        public float[] get​(float[] arr,
                           int offset)
        Description copied from interface: Matrix3dc
        Store the elements of this matrix as float values in column-major order into the supplied float array at the given offset.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given float array.

        Specified by:
        get in interface Matrix3dc
        Parameters:
        arr - the array to write the matrix values into
        offset - the offset into the array
        Returns:
        the passed in array
      • get

        public float[] get​(float[] arr)
        Description copied from interface: Matrix3dc
        Store the elements of this matrix as float values in column-major order into the supplied float array.

        Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given float array.

        In order to specify an explicit offset into the array, use the method Matrix3dc.get(float[], int).

        Specified by:
        get in interface Matrix3dc
        Parameters:
        arr - the array to write the matrix values into
        Returns:
        the passed in array
        See Also:
        Matrix3dc.get(float[], int)
      • set

        public Matrix3d set​(java.nio.DoubleBuffer buffer)
        Set the values of this matrix by reading 9 double values from the given DoubleBuffer in column-major order, starting at its current position.

        The DoubleBuffer is expected to contain the values in column-major order.

        The position of the DoubleBuffer will not be changed by this method.

        Parameters:
        buffer - the DoubleBuffer to read the matrix values from in column-major order
        Returns:
        this
      • set

        public Matrix3d set​(java.nio.FloatBuffer buffer)
        Set the values of this matrix by reading 9 float values from the given FloatBuffer in column-major order, starting at its current position.

        The FloatBuffer is expected to contain the values in column-major order.

        The position of the FloatBuffer will not be changed by this method.

        Parameters:
        buffer - the FloatBuffer to read the matrix values from in column-major order
        Returns:
        this
      • set

        public Matrix3d set​(java.nio.ByteBuffer buffer)
        Set the values of this matrix by reading 9 double values from the given ByteBuffer in column-major order, starting at its current position.

        The ByteBuffer is expected to contain the values in column-major order.

        The position of the ByteBuffer will not be changed by this method.

        Parameters:
        buffer - the ByteBuffer to read the matrix values from in column-major order
        Returns:
        this
      • setFromAddress

        public Matrix3d setFromAddress​(long address)
        Set the values of this matrix by reading 9 double values from off-heap memory in column-major order, starting at the given address.

        This method will throw an UnsupportedOperationException when JOML is used with `-Djoml.nounsafe`.

        This method is unsafe as it can result in a crash of the JVM process when the specified address range does not belong to this process.

        Parameters:
        address - the off-heap memory address to read the matrix values from in column-major order
        Returns:
        this
      • setFloats

        public Matrix3d setFloats​(java.nio.ByteBuffer buffer)
        Set the values of this matrix by reading 9 float values from the given ByteBuffer in column-major order, starting at its current position.

        The ByteBuffer is expected to contain the values in column-major order.

        The position of the ByteBuffer will not be changed by this method.

        Parameters:
        buffer - the ByteBuffer to read the matrix values from in column-major order
        Returns:
        this
      • set

        public Matrix3d set​(Vector3dc col0,
                            Vector3dc col1,
                            Vector3dc col2)
        Set the three columns of this matrix to the supplied vectors, respectively.
        Parameters:
        col0 - the first column
        col1 - the second column
        col2 - the third column
        Returns:
        this
      • zero

        public Matrix3d zero()
        Set all the values within this matrix to 0.
        Returns:
        this
      • identity

        public Matrix3d identity()
        Set this matrix to the identity.
        Returns:
        this
      • scaling

        public Matrix3d scaling​(double factor)
        Set this matrix to be a simple scale matrix, which scales all axes uniformly by the given factor.

        The resulting matrix can be multiplied against another transformation matrix to obtain an additional scaling.

        In order to post-multiply a scaling transformation directly to a matrix, use scale() instead.

        Parameters:
        factor - the scale factor in x, y and z
        Returns:
        this
        See Also:
        scale(double)
      • scaling

        public Matrix3d scaling​(double x,
                                double y,
                                double z)
        Set this matrix to be a simple scale matrix.
        Parameters:
        x - the scale in x
        y - the scale in y
        z - the scale in z
        Returns:
        this
      • scaling

        public Matrix3d scaling​(Vector3dc xyz)
        Set this matrix to be a simple scale matrix which scales the base axes by xyz.x, xyz.y and xyz.z respectively.

        The resulting matrix can be multiplied against another transformation matrix to obtain an additional scaling.

        In order to post-multiply a scaling transformation directly to a matrix use scale() instead.

        Parameters:
        xyz - the scale in x, y and z respectively
        Returns:
        this
        See Also:
        scale(Vector3dc)
      • scale

        public Matrix3d scale​(Vector3dc xyz,
                              Matrix3d dest)
        Description copied from interface: Matrix3dc
        Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively and store the result in dest.

        If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!

        Specified by:
        scale in interface Matrix3dc
        Parameters:
        xyz - the factors of the x, y and z component, respectively
        dest - will hold the result
        Returns:
        dest
      • scale

        public Matrix3d scale​(Vector3dc xyz)
        Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively.

        If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v, the scaling will be applied first!

        Parameters:
        xyz - the factors of the x, y and z component, respectively
        Returns:
        this
      • scale

        public Matrix3d scale​(double x,
                              double y,
                              double z,
                              Matrix3d dest)
        Description copied from interface: Matrix3dc
        Apply scaling to this matrix by scaling the base axes by the given x, y and z factors and store the result in dest.

        If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!

        Specified by:
        scale in interface Matrix3dc
        Parameters:
        x - the factor of the x component
        y - the factor of the y component
        z - the factor of the z component
        dest - will hold the result
        Returns:
        dest
      • scale

        public Matrix3d scale​(double x,
                              double y,
                              double z)
        Apply scaling to this matrix by scaling the base axes by the given x, y and z factors.

        If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!

        Parameters:
        x - the factor of the x component
        y - the factor of the y component
        z - the factor of the z component
        Returns:
        this
      • scale

        public Matrix3d scale​(double xyz,
                              Matrix3d dest)
        Description copied from interface: Matrix3dc
        Apply scaling to this matrix by uniformly scaling all base axes by the given xyz factor and store the result in dest.

        If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!

        Specified by:
        scale in interface Matrix3dc
        Parameters:
        xyz - the factor for all components
        dest - will hold the result
        Returns:
        dest
        See Also:
        Matrix3dc.scale(double, double, double, Matrix3d)
      • scale

        public Matrix3d scale​(double xyz)
        Apply scaling to this matrix by uniformly scaling all base axes by the given xyz factor.

        If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!

        Parameters:
        xyz - the factor for all components
        Returns:
        this
        See Also:
        scale(double, double, double)
      • scaleLocal

        public Matrix3d scaleLocal​(double x,
                                   double y,
                                   double z,
                                   Matrix3d dest)
        Description copied from interface: Matrix3dc
        Pre-multiply scaling to this matrix by scaling the base axes by the given x, y and z factors and store the result in dest.

        If M is this matrix and S the scaling matrix, then the new matrix will be S * M. So when transforming a vector v with the new matrix by using S * M * v , the scaling will be applied last!

        Specified by:
        scaleLocal in interface Matrix3dc
        Parameters:
        x - the factor of the x component
        y - the factor of the y component
        z - the factor of the z component
        dest - will hold the result
        Returns:
        dest
      • scaleLocal

        public Matrix3d scaleLocal​(double x,
                                   double y,
                                   double z)
        Pre-multiply scaling to this matrix by scaling the base axes by the given x, y and z factors.

        If M is this matrix and S the scaling matrix, then the new matrix will be S * M. So when transforming a vector v with the new matrix by using S * M * v, the scaling will be applied last!

        Parameters:
        x - the factor of the x component
        y - the factor of the y component
        z - the factor of the z component
        Returns:
        this
      • rotation

        public Matrix3d rotation​(double angle,
                                 Vector3dc axis)
        Set this matrix to a rotation matrix which rotates the given radians about a given axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.

        In order to post-multiply a rotation transformation directly to a matrix, use rotate() instead.

        Parameters:
        angle - the angle in radians
        axis - the axis to rotate about (needs to be normalized)
        Returns:
        this
        See Also:
        rotate(double, Vector3dc)
      • rotation

        public Matrix3d rotation​(double angle,
                                 Vector3fc axis)
        Set this matrix to a rotation matrix which rotates the given radians about a given axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.

        In order to post-multiply a rotation transformation directly to a matrix, use rotate() instead.

        Parameters:
        angle - the angle in radians
        axis - the axis to rotate about (needs to be normalized)
        Returns:
        this
        See Also:
        rotate(double, Vector3fc)
      • rotation

        public Matrix3d rotation​(AxisAngle4f axisAngle)
        Set this matrix to a rotation transformation using the given AxisAngle4f.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.

        In order to apply the rotation transformation to an existing transformation, use rotate() instead.

        Reference: http://en.wikipedia.org

        Parameters:
        axisAngle - the AxisAngle4f (needs to be normalized)
        Returns:
        this
        See Also:
        rotate(AxisAngle4f)
      • rotation

        public Matrix3d rotation​(AxisAngle4d axisAngle)
        Set this matrix to a rotation transformation using the given AxisAngle4d.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.

        In order to apply the rotation transformation to an existing transformation, use rotate() instead.

        Reference: http://en.wikipedia.org

        Parameters:
        axisAngle - the AxisAngle4d (needs to be normalized)
        Returns:
        this
        See Also:
        rotate(AxisAngle4d)
      • rotation

        public Matrix3d rotation​(double angle,
                                 double x,
                                 double y,
                                 double z)
        Set this matrix to a rotation matrix which rotates the given radians about a given axis.

        The axis described by the three components needs to be a unit vector.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.

        In order to apply the rotation transformation to an existing transformation, use rotate() instead.

        Reference: http://en.wikipedia.org

        Parameters:
        angle - the angle in radians
        x - the x-component of the rotation axis
        y - the y-component of the rotation axis
        z - the z-component of the rotation axis
        Returns:
        this
        See Also:
        rotate(double, double, double, double)
      • rotationX

        public Matrix3d rotationX​(double ang)
        Set this matrix to a rotation transformation about the X axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians
        Returns:
        this
      • rotationY

        public Matrix3d rotationY​(double ang)
        Set this matrix to a rotation transformation about the Y axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians
        Returns:
        this
      • rotationZ

        public Matrix3d rotationZ​(double ang)
        Set this matrix to a rotation transformation about the Z axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians
        Returns:
        this
      • rotationXYZ

        public Matrix3d rotationXYZ​(double angleX,
                                    double angleY,
                                    double angleZ)
        Set this matrix to a rotation of angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        This method is equivalent to calling: rotationX(angleX).rotateY(angleY).rotateZ(angleZ)

        Parameters:
        angleX - the angle to rotate about X
        angleY - the angle to rotate about Y
        angleZ - the angle to rotate about Z
        Returns:
        this
      • rotationZYX

        public Matrix3d rotationZYX​(double angleZ,
                                    double angleY,
                                    double angleX)
        Set this matrix to a rotation of angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        This method is equivalent to calling: rotationZ(angleZ).rotateY(angleY).rotateX(angleX)

        Parameters:
        angleZ - the angle to rotate about Z
        angleY - the angle to rotate about Y
        angleX - the angle to rotate about X
        Returns:
        this
      • rotationYXZ

        public Matrix3d rotationYXZ​(double angleY,
                                    double angleX,
                                    double angleZ)
        Set this matrix to a rotation of angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        This method is equivalent to calling: rotationY(angleY).rotateX(angleX).rotateZ(angleZ)

        Parameters:
        angleY - the angle to rotate about Y
        angleX - the angle to rotate about X
        angleZ - the angle to rotate about Z
        Returns:
        this
      • rotation

        public Matrix3d rotation​(Quaterniondc quat)
        Set this matrix to the rotation - and possibly scaling - transformation of the given Quaterniondc.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.

        In order to apply the rotation transformation to an existing transformation, use rotate() instead.

        Reference: http://en.wikipedia.org

        Parameters:
        quat - the Quaterniondc
        Returns:
        this
        See Also:
        rotate(Quaterniondc)
      • rotation

        public Matrix3d rotation​(Quaternionfc quat)
        Set this matrix to the rotation - and possibly scaling - transformation of the given Quaternionfc.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.

        In order to apply the rotation transformation to an existing transformation, use rotate() instead.

        Reference: http://en.wikipedia.org

        Parameters:
        quat - the Quaternionfc
        Returns:
        this
        See Also:
        rotate(Quaternionfc)
      • transform

        public Vector3d transform​(Vector3d v)
        Description copied from interface: Matrix3dc
        Transform the given vector by this matrix.
        Specified by:
        transform in interface Matrix3dc
        Parameters:
        v - the vector to transform
        Returns:
        v
      • transform

        public Vector3d transform​(Vector3dc v,
                                  Vector3d dest)
        Description copied from interface: Matrix3dc
        Transform the given vector by this matrix and store the result in dest.
        Specified by:
        transform in interface Matrix3dc
        Parameters:
        v - the vector to transform
        dest - will hold the result
        Returns:
        dest
      • transform

        public Vector3f transform​(Vector3f v)
        Description copied from interface: Matrix3dc
        Transform the given vector by this matrix.
        Specified by:
        transform in interface Matrix3dc
        Parameters:
        v - the vector to transform
        Returns:
        v
      • transform

        public Vector3f transform​(Vector3fc v,
                                  Vector3f dest)
        Description copied from interface: Matrix3dc
        Transform the given vector by this matrix and store the result in dest.
        Specified by:
        transform in interface Matrix3dc
        Parameters:
        v - the vector to transform
        dest - will hold the result
        Returns:
        dest
      • transform

        public Vector3d transform​(double x,
                                  double y,
                                  double z,
                                  Vector3d dest)
        Description copied from interface: Matrix3dc
        Transform the vector (x, y, z) by this matrix and store the result in dest.
        Specified by:
        transform in interface Matrix3dc
        Parameters:
        x - the x coordinate of the vector to transform
        y - the y coordinate of the vector to transform
        z - the z coordinate of the vector to transform
        dest - will hold the result
        Returns:
        dest
      • transformTranspose

        public Vector3d transformTranspose​(Vector3d v)
        Description copied from interface: Matrix3dc
        Transform the given vector by the transpose of this matrix.
        Specified by:
        transformTranspose in interface Matrix3dc
        Parameters:
        v - the vector to transform
        Returns:
        v
      • transformTranspose

        public Vector3d transformTranspose​(Vector3dc v,
                                           Vector3d dest)
        Description copied from interface: Matrix3dc
        Transform the given vector by the transpose of this matrix and store the result in dest.
        Specified by:
        transformTranspose in interface Matrix3dc
        Parameters:
        v - the vector to transform
        dest - will hold the result
        Returns:
        dest
      • transformTranspose

        public Vector3d transformTranspose​(double x,
                                           double y,
                                           double z,
                                           Vector3d dest)
        Description copied from interface: Matrix3dc
        Transform the vector (x, y, z) by the transpose of this matrix and store the result in dest.
        Specified by:
        transformTranspose in interface Matrix3dc
        Parameters:
        x - the x coordinate of the vector to transform
        y - the y coordinate of the vector to transform
        z - the z coordinate of the vector to transform
        dest - will hold the result
        Returns:
        dest
      • writeExternal

        public void writeExternal​(java.io.ObjectOutput out)
                           throws java.io.IOException
        Specified by:
        writeExternal in interface java.io.Externalizable
        Throws:
        java.io.IOException
      • readExternal

        public void readExternal​(java.io.ObjectInput in)
                          throws java.io.IOException
        Specified by:
        readExternal in interface java.io.Externalizable
        Throws:
        java.io.IOException
      • rotateX

        public Matrix3d rotateX​(double ang,
                                Matrix3d dest)
        Description copied from interface: Matrix3dc
        Apply rotation about the X axis to this matrix by rotating the given amount of radians and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!

        Reference: http://en.wikipedia.org

        Specified by:
        rotateX in interface Matrix3dc
        Parameters:
        ang - the angle in radians
        dest - will hold the result
        Returns:
        dest
      • rotateX

        public Matrix3d rotateX​(double ang)
        Apply rotation about the X axis to this matrix by rotating the given amount of radians.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians
        Returns:
        this
      • rotateY

        public Matrix3d rotateY​(double ang,
                                Matrix3d dest)
        Description copied from interface: Matrix3dc
        Apply rotation about the Y axis to this matrix by rotating the given amount of radians and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!

        Reference: http://en.wikipedia.org

        Specified by:
        rotateY in interface Matrix3dc
        Parameters:
        ang - the angle in radians
        dest - will hold the result
        Returns:
        dest
      • rotateY

        public Matrix3d rotateY​(double ang)
        Apply rotation about the Y axis to this matrix by rotating the given amount of radians.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians
        Returns:
        this
      • rotateZ

        public Matrix3d rotateZ​(double ang,
                                Matrix3d dest)
        Description copied from interface: Matrix3dc
        Apply rotation about the Z axis to this matrix by rotating the given amount of radians and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!

        Reference: http://en.wikipedia.org

        Specified by:
        rotateZ in interface Matrix3dc
        Parameters:
        ang - the angle in radians
        dest - will hold the result
        Returns:
        dest
      • rotateZ

        public Matrix3d rotateZ​(double ang)
        Apply rotation about the Z axis to this matrix by rotating the given amount of radians.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians
        Returns:
        this
      • rotateXYZ

        public Matrix3d rotateXYZ​(double angleX,
                                  double angleY,
                                  double angleZ)
        Apply rotation of angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the rotation will be applied first!

        This method is equivalent to calling: rotateX(angleX).rotateY(angleY).rotateZ(angleZ)

        Parameters:
        angleX - the angle to rotate about X
        angleY - the angle to rotate about Y
        angleZ - the angle to rotate about Z
        Returns:
        this
      • rotateXYZ

        public Matrix3d rotateXYZ​(double angleX,
                                  double angleY,
                                  double angleZ,
                                  Matrix3d dest)
        Description copied from interface: Matrix3dc
        Apply rotation of angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the rotation will be applied first!

        This method is equivalent to calling: rotateX(angleX, dest).rotateY(angleY).rotateZ(angleZ)

        Specified by:
        rotateXYZ in interface Matrix3dc
        Parameters:
        angleX - the angle to rotate about X
        angleY - the angle to rotate about Y
        angleZ - the angle to rotate about Z
        dest - will hold the result
        Returns:
        dest
      • rotateZYX

        public Matrix3d rotateZYX​(double angleZ,
                                  double angleY,
                                  double angleX)
        Apply rotation of angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the rotation will be applied first!

        This method is equivalent to calling: rotateZ(angleZ).rotateY(angleY).rotateX(angleX)

        Parameters:
        angleZ - the angle to rotate about Z
        angleY - the angle to rotate about Y
        angleX - the angle to rotate about X
        Returns:
        this
      • rotateZYX

        public Matrix3d rotateZYX​(double angleZ,
                                  double angleY,
                                  double angleX,
                                  Matrix3d dest)
        Description copied from interface: Matrix3dc
        Apply rotation of angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the rotation will be applied first!

        This method is equivalent to calling: rotateZ(angleZ, dest).rotateY(angleY).rotateX(angleX)

        Specified by:
        rotateZYX in interface Matrix3dc
        Parameters:
        angleZ - the angle to rotate about Z
        angleY - the angle to rotate about Y
        angleX - the angle to rotate about X
        dest - will hold the result
        Returns:
        dest
      • rotateYXZ

        public Matrix3d rotateYXZ​(Vector3d angles)
        Apply rotation of angles.y radians about the Y axis, followed by a rotation of angles.x radians about the X axis and followed by a rotation of angles.z radians about the Z axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the rotation will be applied first!

        This method is equivalent to calling: rotateY(angles.y).rotateX(angles.x).rotateZ(angles.z)

        Parameters:
        angles - the Euler angles
        Returns:
        this
      • rotateYXZ

        public Matrix3d rotateYXZ​(double angleY,
                                  double angleX,
                                  double angleZ)
        Apply rotation of angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the rotation will be applied first!

        This method is equivalent to calling: rotateY(angleY).rotateX(angleX).rotateZ(angleZ)

        Parameters:
        angleY - the angle to rotate about Y
        angleX - the angle to rotate about X
        angleZ - the angle to rotate about Z
        Returns:
        this
      • rotateYXZ

        public Matrix3d rotateYXZ​(double angleY,
                                  double angleX,
                                  double angleZ,
                                  Matrix3d dest)
        Description copied from interface: Matrix3dc
        Apply rotation of angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the rotation will be applied first!

        This method is equivalent to calling: rotateY(angleY, dest).rotateX(angleX).rotateZ(angleZ)

        Specified by:
        rotateYXZ in interface Matrix3dc
        Parameters:
        angleY - the angle to rotate about Y
        angleX - the angle to rotate about X
        angleZ - the angle to rotate about Z
        dest - will hold the result
        Returns:
        dest
      • rotate

        public Matrix3d rotate​(double ang,
                               double x,
                               double y,
                               double z)
        Apply rotation to this matrix by rotating the given amount of radians about the given axis specified as x, y and z components.

        The axis described by the three components needs to be a unit vector.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians
        x - the x component of the axis
        y - the y component of the axis
        z - the z component of the axis
        Returns:
        this
      • rotate

        public Matrix3d rotate​(double ang,
                               double x,
                               double y,
                               double z,
                               Matrix3d dest)
        Description copied from interface: Matrix3dc
        Apply rotation to this matrix by rotating the given amount of radians about the given axis specified as x, y and z components, and store the result in dest.

        The axis described by the three components needs to be a unit vector.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!

        Reference: http://en.wikipedia.org

        Specified by:
        rotate in interface Matrix3dc
        Parameters:
        ang - the angle in radians
        x - the x component of the axis
        y - the y component of the axis
        z - the z component of the axis
        dest - will hold the result
        Returns:
        dest
      • rotateLocal

        public Matrix3d rotateLocal​(double ang,
                                    double x,
                                    double y,
                                    double z,
                                    Matrix3d dest)
        Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified (x, y, z) axis and store the result in dest.

        The axis described by the three components needs to be a unit vector.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!

        In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use rotation().

        Reference: http://en.wikipedia.org

        Specified by:
        rotateLocal in interface Matrix3dc
        Parameters:
        ang - the angle in radians
        x - the x component of the axis
        y - the y component of the axis
        z - the z component of the axis
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotation(double, double, double, double)
      • rotateLocal

        public Matrix3d rotateLocal​(double ang,
                                    double x,
                                    double y,
                                    double z)
        Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified (x, y, z) axis.

        The axis described by the three components needs to be a unit vector.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!

        In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use rotation().

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians
        x - the x component of the axis
        y - the y component of the axis
        z - the z component of the axis
        Returns:
        this
        See Also:
        rotation(double, double, double, double)
      • rotateLocalX

        public Matrix3d rotateLocalX​(double ang,
                                     Matrix3d dest)
        Pre-multiply a rotation around the X axis to this matrix by rotating the given amount of radians about the X axis and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!

        In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use rotationX().

        Reference: http://en.wikipedia.org

        Specified by:
        rotateLocalX in interface Matrix3dc
        Parameters:
        ang - the angle in radians to rotate about the X axis
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotationX(double)
      • rotateLocalX

        public Matrix3d rotateLocalX​(double ang)
        Pre-multiply a rotation to this matrix by rotating the given amount of radians about the X axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!

        In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use rotationX().

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians to rotate about the X axis
        Returns:
        this
        See Also:
        rotationX(double)
      • rotateLocalY

        public Matrix3d rotateLocalY​(double ang,
                                     Matrix3d dest)
        Pre-multiply a rotation around the Y axis to this matrix by rotating the given amount of radians about the Y axis and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!

        In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use rotationY().

        Reference: http://en.wikipedia.org

        Specified by:
        rotateLocalY in interface Matrix3dc
        Parameters:
        ang - the angle in radians to rotate about the Y axis
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotationY(double)
      • rotateLocalY

        public Matrix3d rotateLocalY​(double ang)
        Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Y axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!

        In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use rotationY().

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians to rotate about the Y axis
        Returns:
        this
        See Also:
        rotationY(double)
      • rotateLocalZ

        public Matrix3d rotateLocalZ​(double ang,
                                     Matrix3d dest)
        Pre-multiply a rotation around the Z axis to this matrix by rotating the given amount of radians about the Z axis and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!

        In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use rotationZ().

        Reference: http://en.wikipedia.org

        Specified by:
        rotateLocalZ in interface Matrix3dc
        Parameters:
        ang - the angle in radians to rotate about the Z axis
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotationZ(double)
      • rotateLocalZ

        public Matrix3d rotateLocalZ​(double ang)
        Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Z axis.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!

        In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use rotationY().

        Reference: http://en.wikipedia.org

        Parameters:
        ang - the angle in radians to rotate about the Z axis
        Returns:
        this
        See Also:
        rotationY(double)
      • rotateLocal

        public Matrix3d rotateLocal​(Quaterniondc quat,
                                    Matrix3d dest)
        Pre-multiply the rotation - and possibly scaling - transformation of the given Quaterniondc to this matrix and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be Q * M. So when transforming a vector v with the new matrix by using Q * M * v, the quaternion rotation will be applied last!

        In order to set the matrix to a rotation transformation without pre-multiplying, use rotation(Quaterniondc).

        Reference: http://en.wikipedia.org

        Specified by:
        rotateLocal in interface Matrix3dc
        Parameters:
        quat - the Quaterniondc
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotation(Quaterniondc)
      • rotateLocal

        public Matrix3d rotateLocal​(Quaterniondc quat)
        Pre-multiply the rotation - and possibly scaling - transformation of the given Quaterniondc to this matrix.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be Q * M. So when transforming a vector v with the new matrix by using Q * M * v, the quaternion rotation will be applied last!

        In order to set the matrix to a rotation transformation without pre-multiplying, use rotation(Quaterniondc).

        Reference: http://en.wikipedia.org

        Parameters:
        quat - the Quaterniondc
        Returns:
        this
        See Also:
        rotation(Quaterniondc)
      • rotateLocal

        public Matrix3d rotateLocal​(Quaternionfc quat,
                                    Matrix3d dest)
        Pre-multiply the rotation - and possibly scaling - transformation of the given Quaternionfc to this matrix and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be Q * M. So when transforming a vector v with the new matrix by using Q * M * v, the quaternion rotation will be applied last!

        In order to set the matrix to a rotation transformation without pre-multiplying, use rotation(Quaternionfc).

        Reference: http://en.wikipedia.org

        Specified by:
        rotateLocal in interface Matrix3dc
        Parameters:
        quat - the Quaternionfc
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotation(Quaternionfc)
      • rotateLocal

        public Matrix3d rotateLocal​(Quaternionfc quat)
        Pre-multiply the rotation - and possibly scaling - transformation of the given Quaternionfc to this matrix.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be Q * M. So when transforming a vector v with the new matrix by using Q * M * v, the quaternion rotation will be applied last!

        In order to set the matrix to a rotation transformation without pre-multiplying, use rotation(Quaternionfc).

        Reference: http://en.wikipedia.org

        Parameters:
        quat - the Quaternionfc
        Returns:
        this
        See Also:
        rotation(Quaternionfc)
      • rotate

        public Matrix3d rotate​(Quaterniondc quat)
        Apply the rotation - and possibly scaling - transformation of the given Quaterniondc to this matrix.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be M * Q. So when transforming a vector v with the new matrix by using M * Q * v, the quaternion rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(Quaterniondc).

        Reference: http://en.wikipedia.org

        Parameters:
        quat - the Quaterniondc
        Returns:
        this
        See Also:
        rotation(Quaterniondc)
      • rotate

        public Matrix3d rotate​(Quaterniondc quat,
                               Matrix3d dest)
        Apply the rotation - and possibly scaling - transformation of the given Quaterniondc to this matrix and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be M * Q. So when transforming a vector v with the new matrix by using M * Q * v, the quaternion rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(Quaterniondc).

        Reference: http://en.wikipedia.org

        Specified by:
        rotate in interface Matrix3dc
        Parameters:
        quat - the Quaterniondc
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotation(Quaterniondc)
      • rotate

        public Matrix3d rotate​(Quaternionfc quat)
        Apply the rotation - and possibly scaling - transformation of the given Quaternionfc to this matrix.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be M * Q. So when transforming a vector v with the new matrix by using M * Q * v, the quaternion rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(Quaternionfc).

        Reference: http://en.wikipedia.org

        Parameters:
        quat - the Quaternionfc
        Returns:
        this
        See Also:
        rotation(Quaternionfc)
      • rotate

        public Matrix3d rotate​(Quaternionfc quat,
                               Matrix3d dest)
        Apply the rotation - and possibly scaling - transformation of the given Quaternionfc to this matrix and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be M * Q. So when transforming a vector v with the new matrix by using M * Q * v, the quaternion rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(Quaternionfc).

        Reference: http://en.wikipedia.org

        Specified by:
        rotate in interface Matrix3dc
        Parameters:
        quat - the Quaternionfc
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotation(Quaternionfc)
      • rotate

        public Matrix3d rotate​(AxisAngle4f axisAngle)
        Apply a rotation transformation, rotating about the given AxisAngle4f, to this matrix.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and A the rotation matrix obtained from the given AxisAngle4f, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the AxisAngle4f rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(AxisAngle4f).

        Reference: http://en.wikipedia.org

        Parameters:
        axisAngle - the AxisAngle4f (needs to be normalized)
        Returns:
        this
        See Also:
        rotate(double, double, double, double), rotation(AxisAngle4f)
      • rotate

        public Matrix3d rotate​(AxisAngle4f axisAngle,
                               Matrix3d dest)
        Apply a rotation transformation, rotating about the given AxisAngle4f and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and A the rotation matrix obtained from the given AxisAngle4f, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the AxisAngle4f rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(AxisAngle4f).

        Reference: http://en.wikipedia.org

        Specified by:
        rotate in interface Matrix3dc
        Parameters:
        axisAngle - the AxisAngle4f (needs to be normalized)
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotate(double, double, double, double), rotation(AxisAngle4f)
      • rotate

        public Matrix3d rotate​(AxisAngle4d axisAngle)
        Apply a rotation transformation, rotating about the given AxisAngle4d, to this matrix.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and A the rotation matrix obtained from the given AxisAngle4d, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the AxisAngle4d rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(AxisAngle4d).

        Reference: http://en.wikipedia.org

        Parameters:
        axisAngle - the AxisAngle4d (needs to be normalized)
        Returns:
        this
        See Also:
        rotate(double, double, double, double), rotation(AxisAngle4d)
      • rotate

        public Matrix3d rotate​(AxisAngle4d axisAngle,
                               Matrix3d dest)
        Apply a rotation transformation, rotating about the given AxisAngle4d and store the result in dest.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and A the rotation matrix obtained from the given AxisAngle4d, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the AxisAngle4d rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(AxisAngle4d).

        Reference: http://en.wikipedia.org

        Specified by:
        rotate in interface Matrix3dc
        Parameters:
        axisAngle - the AxisAngle4d (needs to be normalized)
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotate(double, double, double, double), rotation(AxisAngle4d)
      • rotate

        public Matrix3d rotate​(double angle,
                               Vector3dc axis)
        Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.

        The axis described by the axis vector needs to be a unit vector.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and A the rotation matrix obtained from the given angle and axis, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the axis-angle rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(double, Vector3dc).

        Reference: http://en.wikipedia.org

        Parameters:
        angle - the angle in radians
        axis - the rotation axis (needs to be normalized)
        Returns:
        this
        See Also:
        rotate(double, double, double, double), rotation(double, Vector3dc)
      • rotate

        public Matrix3d rotate​(double angle,
                               Vector3dc axis,
                               Matrix3d dest)
        Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.

        The axis described by the axis vector needs to be a unit vector.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and A the rotation matrix obtained from the given axis and angle, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the axis-angle rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(double, Vector3dc).

        Reference: http://en.wikipedia.org

        Specified by:
        rotate in interface Matrix3dc
        Parameters:
        angle - the angle in radians
        axis - the rotation axis (needs to be normalized)
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotate(double, double, double, double), rotation(double, Vector3dc)
      • rotate

        public Matrix3d rotate​(double angle,
                               Vector3fc axis)
        Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.

        The axis described by the axis vector needs to be a unit vector.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and A the rotation matrix obtained from the given angle and axis, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the axis-angle rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(double, Vector3fc).

        Reference: http://en.wikipedia.org

        Parameters:
        angle - the angle in radians
        axis - the rotation axis (needs to be normalized)
        Returns:
        this
        See Also:
        rotate(double, double, double, double), rotation(double, Vector3fc)
      • rotate

        public Matrix3d rotate​(double angle,
                               Vector3fc axis,
                               Matrix3d dest)
        Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.

        The axis described by the axis vector needs to be a unit vector.

        When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

        If M is this matrix and A the rotation matrix obtained from the given axis and angle, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the axis-angle rotation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying, use rotation(double, Vector3fc).

        Reference: http://en.wikipedia.org

        Specified by:
        rotate in interface Matrix3dc
        Parameters:
        angle - the angle in radians
        axis - the rotation axis (needs to be normalized)
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotate(double, double, double, double), rotation(double, Vector3fc)
      • getRow

        public Vector3d getRow​(int row,
                               Vector3d dest)
                        throws java.lang.IndexOutOfBoundsException
        Description copied from interface: Matrix3dc
        Get the row at the given row index, starting with 0.
        Specified by:
        getRow in interface Matrix3dc
        Parameters:
        row - the row index in [0..2]
        dest - will hold the row components
        Returns:
        the passed in destination
        Throws:
        java.lang.IndexOutOfBoundsException - if row is not in [0..2]
      • setRow

        public Matrix3d setRow​(int row,
                               Vector3dc src)
                        throws java.lang.IndexOutOfBoundsException
        Set the row at the given row index, starting with 0.
        Parameters:
        row - the row index in [0..2]
        src - the row components to set
        Returns:
        this
        Throws:
        java.lang.IndexOutOfBoundsException - if row is not in [0..2]
      • setRow

        public Matrix3d setRow​(int row,
                               double x,
                               double y,
                               double z)
                        throws java.lang.IndexOutOfBoundsException
        Set the row at the given row index, starting with 0.
        Parameters:
        row - the column index in [0..2]
        x - the first element in the row
        y - the second element in the row
        z - the third element in the row
        Returns:
        this
        Throws:
        java.lang.IndexOutOfBoundsException - if row is not in [0..2]
      • getColumn

        public Vector3d getColumn​(int column,
                                  Vector3d dest)
                           throws java.lang.IndexOutOfBoundsException
        Description copied from interface: Matrix3dc
        Get the column at the given column index, starting with 0.
        Specified by:
        getColumn in interface Matrix3dc
        Parameters:
        column - the column index in [0..2]
        dest - will hold the column components
        Returns:
        the passed in destination
        Throws:
        java.lang.IndexOutOfBoundsException - if column is not in [0..2]
      • setColumn

        public Matrix3d setColumn​(int column,
                                  Vector3dc src)
                           throws java.lang.IndexOutOfBoundsException
        Set the column at the given column index, starting with 0.
        Parameters:
        column - the column index in [0..2]
        src - the column components to set
        Returns:
        this
        Throws:
        java.lang.IndexOutOfBoundsException - if column is not in [0..2]
      • setColumn

        public Matrix3d setColumn​(int column,
                                  double x,
                                  double y,
                                  double z)
                           throws java.lang.IndexOutOfBoundsException
        Set the column at the given column index, starting with 0.
        Parameters:
        column - the column index in [0..2]
        x - the first element in the column
        y - the second element in the column
        z - the third element in the column
        Returns:
        this
        Throws:
        java.lang.IndexOutOfBoundsException - if column is not in [0..2]
      • get

        public double get​(int column,
                          int row)
        Description copied from interface: Matrix3dc
        Get the matrix element value at the given column and row.
        Specified by:
        get in interface Matrix3dc
        Parameters:
        column - the colum index in [0..2]
        row - the row index in [0..2]
        Returns:
        the element value
      • set

        public Matrix3d set​(int column,
                            int row,
                            double value)
        Set the matrix element at the given column and row to the specified value.
        Parameters:
        column - the colum index in [0..2]
        row - the row index in [0..2]
        value - the value
        Returns:
        this
      • normal

        public Matrix3d normal()
        Set this matrix to its own normal matrix.

        Please note that, if this is an orthogonal matrix or a matrix whose columns are orthogonal vectors, then this method need not be invoked, since in that case this itself is its normal matrix. In this case, use set(Matrix3dc) to set a given Matrix3f to this matrix.

        Returns:
        this
        See Also:
        set(Matrix3dc)
      • normal

        public Matrix3d normal​(Matrix3d dest)
        Compute a normal matrix from this matrix and store it into dest.

        Please note that, if this is an orthogonal matrix or a matrix whose columns are orthogonal vectors, then this method need not be invoked, since in that case this itself is its normal matrix. In this case, use set(Matrix3dc) to set a given Matrix3d to this matrix.

        Specified by:
        normal in interface Matrix3dc
        Parameters:
        dest - will hold the result
        Returns:
        dest
        See Also:
        set(Matrix3dc)
      • lookAlong

        public Matrix3d lookAlong​(Vector3dc dir,
                                  Vector3dc up)
        Apply a rotation transformation to this matrix to make -z point along dir.

        If M is this matrix and L the lookalong rotation matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookalong rotation transformation will be applied first!

        In order to set the matrix to a lookalong transformation without post-multiplying it, use setLookAlong().

        Parameters:
        dir - the direction in space to look along
        up - the direction of 'up'
        Returns:
        this
        See Also:
        lookAlong(double, double, double, double, double, double), setLookAlong(Vector3dc, Vector3dc)
      • lookAlong

        public Matrix3d lookAlong​(Vector3dc dir,
                                  Vector3dc up,
                                  Matrix3d dest)
        Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.

        If M is this matrix and L the lookalong rotation matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookalong rotation transformation will be applied first!

        In order to set the matrix to a lookalong transformation without post-multiplying it, use setLookAlong().

        Specified by:
        lookAlong in interface Matrix3dc
        Parameters:
        dir - the direction in space to look along
        up - the direction of 'up'
        dest - will hold the result
        Returns:
        dest
        See Also:
        lookAlong(double, double, double, double, double, double), setLookAlong(Vector3dc, Vector3dc)
      • lookAlong

        public Matrix3d lookAlong​(double dirX,
                                  double dirY,
                                  double dirZ,
                                  double upX,
                                  double upY,
                                  double upZ,
                                  Matrix3d dest)
        Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.

        If M is this matrix and L the lookalong rotation matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookalong rotation transformation will be applied first!

        In order to set the matrix to a lookalong transformation without post-multiplying it, use setLookAlong()

        Specified by:
        lookAlong in interface Matrix3dc
        Parameters:
        dirX - the x-coordinate of the direction to look along
        dirY - the y-coordinate of the direction to look along
        dirZ - the z-coordinate of the direction to look along
        upX - the x-coordinate of the up vector
        upY - the y-coordinate of the up vector
        upZ - the z-coordinate of the up vector
        dest - will hold the result
        Returns:
        dest
        See Also:
        setLookAlong(double, double, double, double, double, double)
      • lookAlong

        public Matrix3d lookAlong​(double dirX,
                                  double dirY,
                                  double dirZ,
                                  double upX,
                                  double upY,
                                  double upZ)
        Apply a rotation transformation to this matrix to make -z point along dir.

        If M is this matrix and L the lookalong rotation matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookalong rotation transformation will be applied first!

        In order to set the matrix to a lookalong transformation without post-multiplying it, use setLookAlong()

        Parameters:
        dirX - the x-coordinate of the direction to look along
        dirY - the y-coordinate of the direction to look along
        dirZ - the z-coordinate of the direction to look along
        upX - the x-coordinate of the up vector
        upY - the y-coordinate of the up vector
        upZ - the z-coordinate of the up vector
        Returns:
        this
        See Also:
        setLookAlong(double, double, double, double, double, double)
      • setLookAlong

        public Matrix3d setLookAlong​(double dirX,
                                     double dirY,
                                     double dirZ,
                                     double upX,
                                     double upY,
                                     double upZ)
        Set this matrix to a rotation transformation to make -z point along dir.

        In order to apply the lookalong transformation to any previous existing transformation, use lookAlong()

        Parameters:
        dirX - the x-coordinate of the direction to look along
        dirY - the y-coordinate of the direction to look along
        dirZ - the z-coordinate of the direction to look along
        upX - the x-coordinate of the up vector
        upY - the y-coordinate of the up vector
        upZ - the z-coordinate of the up vector
        Returns:
        this
        See Also:
        setLookAlong(double, double, double, double, double, double), lookAlong(double, double, double, double, double, double)
      • getScale

        public Vector3d getScale​(Vector3d dest)
        Description copied from interface: Matrix3dc
        Get the scaling factors of this matrix for the three base axes.
        Specified by:
        getScale in interface Matrix3dc
        Parameters:
        dest - will hold the scaling factors for x, y and z
        Returns:
        dest
      • positiveZ

        public Vector3d positiveZ​(Vector3d dir)
        Description copied from interface: Matrix3dc
        Obtain the direction of +Z before the transformation represented by this matrix is applied.

        This method is equivalent to the following code:

         Matrix3d inv = new Matrix3d(this).invert();
         inv.transform(dir.set(0, 0, 1)).normalize();
         
        If this is already an orthogonal matrix, then consider using Matrix3dc.normalizedPositiveZ(Vector3d) instead.

        Reference: http://www.euclideanspace.com

        Specified by:
        positiveZ in interface Matrix3dc
        Parameters:
        dir - will hold the direction of +Z
        Returns:
        dir
      • normalizedPositiveZ

        public Vector3d normalizedPositiveZ​(Vector3d dir)
        Description copied from interface: Matrix3dc
        Obtain the direction of +Z before the transformation represented by this orthogonal matrix is applied. This method only produces correct results if this is an orthogonal matrix.

        This method is equivalent to the following code:

         Matrix3d inv = new Matrix3d(this).transpose();
         inv.transform(dir.set(0, 0, 1));
         

        Reference: http://www.euclideanspace.com

        Specified by:
        normalizedPositiveZ in interface Matrix3dc
        Parameters:
        dir - will hold the direction of +Z
        Returns:
        dir
      • positiveX

        public Vector3d positiveX​(Vector3d dir)
        Description copied from interface: Matrix3dc
        Obtain the direction of +X before the transformation represented by this matrix is applied.

        This method is equivalent to the following code:

         Matrix3d inv = new Matrix3d(this).invert();
         inv.transform(dir.set(1, 0, 0)).normalize();
         
        If this is already an orthogonal matrix, then consider using Matrix3dc.normalizedPositiveX(Vector3d) instead.

        Reference: http://www.euclideanspace.com

        Specified by:
        positiveX in interface Matrix3dc
        Parameters:
        dir - will hold the direction of +X
        Returns:
        dir
      • normalizedPositiveX

        public Vector3d normalizedPositiveX​(Vector3d dir)
        Description copied from interface: Matrix3dc
        Obtain the direction of +X before the transformation represented by this orthogonal matrix is applied. This method only produces correct results if this is an orthogonal matrix.

        This method is equivalent to the following code:

         Matrix3d inv = new Matrix3d(this).transpose();
         inv.transform(dir.set(1, 0, 0));
         

        Reference: http://www.euclideanspace.com

        Specified by:
        normalizedPositiveX in interface Matrix3dc
        Parameters:
        dir - will hold the direction of +X
        Returns:
        dir
      • positiveY

        public Vector3d positiveY​(Vector3d dir)
        Description copied from interface: Matrix3dc
        Obtain the direction of +Y before the transformation represented by this matrix is applied.

        This method is equivalent to the following code:

         Matrix3d inv = new Matrix3d(this).invert();
         inv.transform(dir.set(0, 1, 0)).normalize();
         
        If this is already an orthogonal matrix, then consider using Matrix3dc.normalizedPositiveY(Vector3d) instead.

        Reference: http://www.euclideanspace.com

        Specified by:
        positiveY in interface Matrix3dc
        Parameters:
        dir - will hold the direction of +Y
        Returns:
        dir
      • normalizedPositiveY

        public Vector3d normalizedPositiveY​(Vector3d dir)
        Description copied from interface: Matrix3dc
        Obtain the direction of +Y before the transformation represented by this orthogonal matrix is applied. This method only produces correct results if this is an orthogonal matrix.

        This method is equivalent to the following code:

         Matrix3d inv = new Matrix3d(this).transpose();
         inv.transform(dir.set(0, 1, 0));
         

        Reference: http://www.euclideanspace.com

        Specified by:
        normalizedPositiveY in interface Matrix3dc
        Parameters:
        dir - will hold the direction of +Y
        Returns:
        dir
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class java.lang.Object
      • equals

        public boolean equals​(java.lang.Object obj)
        Overrides:
        equals in class java.lang.Object
      • equals

        public boolean equals​(Matrix3dc m,
                              double delta)
        Description copied from interface: Matrix3dc
        Compare the matrix elements of this matrix with the given matrix using the given delta and return whether all of them are equal within a maximum difference of delta.

        Please note that this method is not used by any data structure such as ArrayList HashSet or HashMap and their operations, such as ArrayList.contains(Object) or HashSet.remove(Object), since those data structures only use the Object.equals(Object) and Object.hashCode() methods.

        Specified by:
        equals in interface Matrix3dc
        Parameters:
        m - the other matrix
        delta - the allowed maximum difference
        Returns:
        true whether all of the matrix elements are equal; false otherwise
      • swap

        public Matrix3d swap​(Matrix3d other)
        Exchange the values of this matrix with the given other matrix.
        Parameters:
        other - the other matrix to exchange the values with
        Returns:
        this
      • add

        public Matrix3d add​(Matrix3dc other)
        Component-wise add this and other.
        Parameters:
        other - the other addend
        Returns:
        this
      • add

        public Matrix3d add​(Matrix3dc other,
                            Matrix3d dest)
        Description copied from interface: Matrix3dc
        Component-wise add this and other and store the result in dest.
        Specified by:
        add in interface Matrix3dc
        Parameters:
        other - the other addend
        dest - will hold the result
        Returns:
        dest
      • sub

        public Matrix3d sub​(Matrix3dc subtrahend)
        Component-wise subtract subtrahend from this.
        Parameters:
        subtrahend - the subtrahend
        Returns:
        this
      • sub

        public Matrix3d sub​(Matrix3dc subtrahend,
                            Matrix3d dest)
        Description copied from interface: Matrix3dc
        Component-wise subtract subtrahend from this and store the result in dest.
        Specified by:
        sub in interface Matrix3dc
        Parameters:
        subtrahend - the subtrahend
        dest - will hold the result
        Returns:
        dest
      • mulComponentWise

        public Matrix3d mulComponentWise​(Matrix3dc other)
        Component-wise multiply this by other.
        Parameters:
        other - the other matrix
        Returns:
        this
      • mulComponentWise

        public Matrix3d mulComponentWise​(Matrix3dc other,
                                         Matrix3d dest)
        Description copied from interface: Matrix3dc
        Component-wise multiply this by other and store the result in dest.
        Specified by:
        mulComponentWise in interface Matrix3dc
        Parameters:
        other - the other matrix
        dest - will hold the result
        Returns:
        dest
      • setSkewSymmetric

        public Matrix3d setSkewSymmetric​(double a,
                                         double b,
                                         double c)
        Set this matrix to a skew-symmetric matrix using the following layout:
          0,  a, -b
         -a,  0,  c
          b, -c,  0
         
        Reference: https://en.wikipedia.org
        Parameters:
        a - the value used for the matrix elements m01 and m10
        b - the value used for the matrix elements m02 and m20
        c - the value used for the matrix elements m12 and m21
        Returns:
        this
      • lerp

        public Matrix3d lerp​(Matrix3dc other,
                             double t)
        Linearly interpolate this and other using the given interpolation factor t and store the result in this.

        If t is 0.0 then the result is this. If the interpolation factor is 1.0 then the result is other.

        Parameters:
        other - the other matrix
        t - the interpolation factor between 0.0 and 1.0
        Returns:
        this
      • lerp

        public Matrix3d lerp​(Matrix3dc other,
                             double t,
                             Matrix3d dest)
        Description copied from interface: Matrix3dc
        Linearly interpolate this and other using the given interpolation factor t and store the result in dest.

        If t is 0.0 then the result is this. If the interpolation factor is 1.0 then the result is other.

        Specified by:
        lerp in interface Matrix3dc
        Parameters:
        other - the other matrix
        t - the interpolation factor between 0.0 and 1.0
        dest - will hold the result
        Returns:
        dest
      • rotateTowards

        public Matrix3d rotateTowards​(Vector3dc direction,
                                      Vector3dc up,
                                      Matrix3d dest)
        Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction and store the result in dest.

        If M is this matrix and L the lookat matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookat transformation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying it, use rotationTowards().

        This method is equivalent to calling: mul(new Matrix3d().lookAlong(new Vector3d(dir).negate(), up).invert(), dest)

        Specified by:
        rotateTowards in interface Matrix3dc
        Parameters:
        direction - the direction to rotate towards
        up - the model's up vector
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotateTowards(double, double, double, double, double, double, Matrix3d), rotationTowards(Vector3dc, Vector3dc)
      • rotateTowards

        public Matrix3d rotateTowards​(Vector3dc direction,
                                      Vector3dc up)
        Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction.

        If M is this matrix and L the lookat matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookat transformation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying it, use rotationTowards().

        This method is equivalent to calling: mul(new Matrix3d().lookAlong(new Vector3d(dir).negate(), up).invert())

        Parameters:
        direction - the direction to orient towards
        up - the up vector
        Returns:
        this
        See Also:
        rotateTowards(double, double, double, double, double, double), rotationTowards(Vector3dc, Vector3dc)
      • rotateTowards

        public Matrix3d rotateTowards​(double dirX,
                                      double dirY,
                                      double dirZ,
                                      double upX,
                                      double upY,
                                      double upZ)
        Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction.

        If M is this matrix and L the lookat matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookat transformation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying it, use rotationTowards().

        This method is equivalent to calling: mul(new Matrix3d().lookAlong(-dirX, -dirY, -dirZ, upX, upY, upZ).invert())

        Parameters:
        dirX - the x-coordinate of the direction to rotate towards
        dirY - the y-coordinate of the direction to rotate towards
        dirZ - the z-coordinate of the direction to rotate towards
        upX - the x-coordinate of the up vector
        upY - the y-coordinate of the up vector
        upZ - the z-coordinate of the up vector
        Returns:
        this
        See Also:
        rotateTowards(Vector3dc, Vector3dc), rotationTowards(double, double, double, double, double, double)
      • rotateTowards

        public Matrix3d rotateTowards​(double dirX,
                                      double dirY,
                                      double dirZ,
                                      double upX,
                                      double upY,
                                      double upZ,
                                      Matrix3d dest)
        Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with dir and store the result in dest.

        If M is this matrix and L the lookat matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookat transformation will be applied first!

        In order to set the matrix to a rotation transformation without post-multiplying it, use rotationTowards().

        This method is equivalent to calling: mul(new Matrix3d().lookAlong(-dirX, -dirY, -dirZ, upX, upY, upZ).invert(), dest)

        Specified by:
        rotateTowards in interface Matrix3dc
        Parameters:
        dirX - the x-coordinate of the direction to rotate towards
        dirY - the y-coordinate of the direction to rotate towards
        dirZ - the z-coordinate of the direction to rotate towards
        upX - the x-coordinate of the up vector
        upY - the y-coordinate of the up vector
        upZ - the z-coordinate of the up vector
        dest - will hold the result
        Returns:
        dest
        See Also:
        rotateTowards(Vector3dc, Vector3dc), rotationTowards(double, double, double, double, double, double)
      • rotationTowards

        public Matrix3d rotationTowards​(double dirX,
                                        double dirY,
                                        double dirZ,
                                        double upX,
                                        double upY,
                                        double upZ)
        Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local -z axis with center - eye.

        In order to apply the rotation transformation to a previous existing transformation, use rotateTowards.

        This method is equivalent to calling: setLookAlong(-dirX, -dirY, -dirZ, upX, upY, upZ).invert()

        Parameters:
        dirX - the x-coordinate of the direction to rotate towards
        dirY - the y-coordinate of the direction to rotate towards
        dirZ - the z-coordinate of the direction to rotate towards
        upX - the x-coordinate of the up vector
        upY - the y-coordinate of the up vector
        upZ - the z-coordinate of the up vector
        Returns:
        this
        See Also:
        rotateTowards(Vector3dc, Vector3dc), rotationTowards(double, double, double, double, double, double)
      • getEulerAnglesZYX

        public Vector3d getEulerAnglesZYX​(Vector3d dest)
        Extract the Euler angles from the rotation represented by this matrix and store the extracted Euler angles in dest.

        This method assumes that this matrix only represents a rotation without scaling.

        Note that the returned Euler angles must be applied in the order Z * Y * X to obtain the identical matrix. This means that calling rotateZYX(double, double, double) using the obtained Euler angles will yield the same rotation as the original matrix from which the Euler angles were obtained, so in the below code the matrix m2 should be identical to m (disregarding possible floating-point inaccuracies).

         Matrix3d m = ...; // <- matrix only representing rotation
         Matrix3d n = new Matrix3d();
         n.rotateZYX(m.getEulerAnglesZYX(new Vector3d()));
         

        Reference: http://nghiaho.com/

        Specified by:
        getEulerAnglesZYX in interface Matrix3dc
        Parameters:
        dest - will hold the extracted Euler angles
        Returns:
        dest
      • obliqueZ

        public Matrix3d obliqueZ​(double a,
                                 double b)
        Apply an oblique projection transformation to this matrix with the given values for a and b.

        If M is this matrix and O the oblique transformation matrix, then the new matrix will be M * O. So when transforming a vector v with the new matrix by using M * O * v, the oblique transformation will be applied first!

        The oblique transformation is defined as:

         x' = x + a*z
         y' = y + a*z
         z' = z
         
        or in matrix form:
         1 0 a
         0 1 b
         0 0 1
         
        Parameters:
        a - the value for the z factor that applies to x
        b - the value for the z factor that applies to y
        Returns:
        this
      • obliqueZ

        public Matrix3d obliqueZ​(double a,
                                 double b,
                                 Matrix3d dest)
        Apply an oblique projection transformation to this matrix with the given values for a and b and store the result in dest.

        If M is this matrix and O the oblique transformation matrix, then the new matrix will be M * O. So when transforming a vector v with the new matrix by using M * O * v, the oblique transformation will be applied first!

        The oblique transformation is defined as:

         x' = x + a*z
         y' = y + a*z
         z' = z
         
        or in matrix form:
         1 0 a
         0 1 b
         0 0 1
         
        Specified by:
        obliqueZ in interface Matrix3dc
        Parameters:
        a - the value for the z factor that applies to x
        b - the value for the z factor that applies to y
        dest - will hold the result
        Returns:
        dest