Class Matrix4

Component-wise add this and other.

Component-wise add the upper 4x3 submatrices of this and other.

Compute the extents of the coordinate system before this {@link #isAffine() affine} transformation was applied and store the resulting corner coordinates in corner and the span vectors in xDir, yDir and zDir.

That means, given the maximum extents of the coordinate system between [-1..+1] in all dimensions, this method returns one corner and the length and direction of the three base axis vectors in the coordinate system before this transformation is applied, which transforms into the corner coordinates [-1, +1].

This method is equivalent to computing at least three adjacent corners using {@link #frustumCorner(int, Vector3d)} and subtracting them to obtain the length and direction of the span vectors.

Apply an arcball view transformation to this matrix with the given radius and center position of the arcball and the specified X and Y rotation angles.

This method is equivalent to calling: translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-center.x, -center.y, -center.z)

Set this matrix to a cylindrical billboard transformation that rotates the local +Z axis of a given object with position objPos towards a target position at targetPos while constraining a cylindrical rotation around the given up vector.

This method can be used to create the complete model transformation for a given object, including the translation of the object to its position objPos.

Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position objPos towards a target position at targetPos.

This method can be used to create the complete model transformation for a given object, including the translation of the object to its position objPos.

If preserving an up vector is not necessary when rotating the +Z axis, then a shortest arc rotation can be obtained using {@link #billboardSpherical(Vector3dc, Vector3dc)}.

Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position objPos towards a target position at targetPos using a shortest arc rotation by not preserving any up vector of the object.

This method can be used to create the complete model transformation for a given object, including the translation of the object to its position objPos.

In order to specify an up vector which needs to be maintained when rotating the +Z axis of the object, use {@link #billboardSpherical(Vector3, Vector3, Vector3)}.

Compute the cofactor matrix of the upper left 3x3 submatrix of this and store it into dest.

The cofactor matrix can be used instead of {@link #normal(Matrix3d)} to transform normals when the orientation of the normals with respect to the surface should be preserved.

Compute the cofactor matrix of the upper left 3x3 submatrix of this and store it into dest. All other values of dest will be set to {@link #identity() identity}.

The cofactor matrix can be used instead of {@link #normal(Matrix4d)} to transform normals when the orientation of the normals with respect to the surface should be preserved.

Component-wise add the upper 4x3 submatrices of this and other by first multiplying each component of other's 4x3 submatrix by otherFactor and adding that result to this.

The matrix other will not be changed.

Apply an arbitrary perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range to this matrix and store the result in dest.

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

In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustum(double, double, double, double, double, double, boolean) setFrustum()}.

Reference: http://www.songho.ca

Compute the axis-aligned bounding box of the frustum described by this matrix and store the minimum corner coordinates in the given min and the maximum corner coordinates in the given max vector.

The matrix this is assumed to be the {@link #invert() inverse} of the origial view-projection matrix for which to compute the axis-aligned bounding box in world-space.

The axis-aligned bounding box of the unit frustum is (-1, -1, -1), (1, 1, 1).

Apply an arbitrary perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range to this matrix and store the result in dest.

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

In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustumLH(double, double, double, double, double, double, boolean) setFrustumLH()}.

Reference: http://www.songho.ca

Apply a rotation transformation, rotating about the given {@link 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 {@link 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 {@link AxisAngle4d} rotation will be applied first!

In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(AxisAngle4d)}.

Reference: http://en.wikipedia.org

Reset this matrix to the identity.

Please note that if a call to {@link #identity()} is immediately followed by a call to: {@link #translate(double, double, double) translate}, {@link #rotate(double, double, double, double) rotate}, {@link #scale(double, double, double) scale}, {@link #perspective(double, double, double, double) perspective}, {@link #frustum(double, double, double, double, double, double) frustum}, {@link #ortho(double, double, double, double, double, double) ortho}, {@link #ortho2D(double, double, double, double) ortho2D}, {@link #lookAt(double, double, double, double, double, double, double, double, double) lookAt}, {@link #lookAlong(double, double, double, double, double, double) lookAlong}, or any of their overloads, then the call to {@link #identity()} can be omitted and the subsequent call replaced with: {@link #translation(double, double, double) translation}, {@link #rotation(double, double, double, double) rotation}, {@link #scaling(double, double, double) scaling}, {@link #setPerspective(double, double, double, double) setPerspective}, {@link #setFrustum(double, double, double, double, double, double) setFrustum}, {@link #setOrtho(double, double, double, double, double, double) setOrtho}, {@link #setOrtho2D(double, double, double, double) setOrtho2D}, {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt}, {@link #setLookAlong(double, double, double, double, double, double) setLookAlong}, or any of their overloads.

Invert this matrix.

If this matrix represents an {@link #isAffine() affine} transformation, such as translation, rotation, scaling and shearing, and thus its last row is equal to (0, 0, 0, 1), then {@link #invertAffine()} can be used instead of this method.

Invert this matrix by assuming that it is an {@link #isAffine() affine} transformation (i.e. its last row is equal to (0, 0, 0, 1)).

If this is an arbitrary perspective projection matrix obtained via one of the {@link #frustum(double, double, double, double, double, double) frustum()} methods or via {@link #setFrustum(double, double, double, double, double, double) setFrustum()}, then this method builds the inverse of this.

This method can be used to quickly obtain the inverse of a perspective projection matrix.

If this matrix represents a symmetric perspective frustum transformation, as obtained via {@link #perspective(double, double, double, double) perspective()}, then {@link #invertPerspective()} should be used instead.

Invert this orthographic projection matrix.

This method can be used to quickly obtain the inverse of an orthographic projection matrix.

If this is a perspective projection matrix obtained via one of the {@link #perspective(double, double, double, double) perspective()} methods or via {@link #setPerspective(double, double, double, double) setPerspective()}, that is, if this is a symmetrical perspective frustum transformation, then this method builds the inverse of this.

This method can be used to quickly obtain the inverse of a perspective projection matrix when being obtained via {@link #perspective(double, double, double, double) perspective()}.

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.

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!

This is equivalent to calling {@link #lookAt(Vector3dc, Vector3dc, Vector3dc) lookAt} with eye = (0, 0, 0) and center = dir.

In order to set the matrix to a lookalong transformation without post-multiplying it, use {@link #setLookAlong(Vector3dc, Vector3dc) setLookAlong()}.

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!

This is equivalent to calling {@link #lookAt(double, double, double, double, double, double, double, double, double) lookAt()} with eye = (0, 0, 0) and center = dir.

In order to set the matrix to a lookalong transformation without post-multiplying it, use {@link #setLookAlong(double, double, double, double, double, double) setLookAlong()}

Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye 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 lookat transformation without post-multiplying it, use {@link #setLookAt(Vector3dc, Vector3dc, Vector3dc)}.

Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye 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 lookat transformation without post-multiplying it, use {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt()}.

Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye 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 lookat transformation without post-multiplying it, use {@link #setLookAtLH(Vector3dc, Vector3dc, Vector3dc)}.

Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye 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 lookat transformation without post-multiplying it, use {@link #setLookAtLH(double, double, double, double, double, double, double, double, double) setLookAtLH()}.

Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye and store the result in dest.

This method assumes this to be a perspective transformation, obtained via {@link #frustum(double, double, double, double, double, double) frustum()} or {@link #perspective(double, double, double, double) perspective()} or one of their overloads.

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 lookat transformation without post-multiplying it, use {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt()}.

Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye and store the result in dest.

This method assumes this to be a perspective transformation, obtained via {@link #frustumLH(double, double, double, double, double, double) frustumLH()} or {@link #perspectiveLH(double, double, double, double) perspectiveLH()} or one of their overloads.

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 lookat transformation without post-multiplying it, use {@link #setLookAtLH(double, double, double, double, double, double, double, double, double) setLookAtLH()}.

Multiply this by the matrix

1 0 0 0
0 0 1 0
0 1 0 0
0 0 0 1

Multiply this by the matrix

1 0  0 0
0 0 -1 0
0 1  0 0
0 0  0 1

Multiply this by the matrix

1  0  0 0
0 -1  0 0
0  0 -1 0
0  0  0 1

Multiply this by the matrix

1  0 0 0
0  0 1 0
0 -1 0 0
0  0 0 1

Multiply this by the matrix

1  0  0 0
0  0 -1 0
0 -1  0 0
0  0  0 1

Multiply this by the matrix

0 1 0 0
1 0 0 0
0 0 1 0
0 0 0 1

Multiply this by the matrix

0 0 1 0
1 0 0 0
0 1 0 0
0 0 0 1

Multiply this by the matrix

0 0 -1 0
1 0  0 0
0 1  0 0
0 0  0 1

Multiply this by the matrix

0 -1 0 0
1  0 0 0
0  0 1 0
0  0 0 1

Multiply this by the matrix

0 -1  0 0
1  0  0 0
0  0 -1 0
0  0  0 1

Multiply this by the matrix

0  0 1 0
1  0 0 0
0 -1 0 0
0  0 0 1

Multiply this by the matrix

0  0 -1 0
1  0  0 0
0 -1  0 0
0  0  0 1

Multiply this by the matrix

0 1 0 0
0 0 1 0
1 0 0 0
0 0 0 1

Multiply this by the matrix

0 1  0 0
0 0 -1 0
1 0  0 0
0 0  0 1

Multiply this by the matrix

0 0 1 0
0 1 0 0
1 0 0 0
0 0 0 1

Multiply this by the matrix

0 0 -1 0
0 1  0 0
1 0  0 0
0 0  0 1

Multiply this by the matrix

0 -1 0 0
0  0 1 0
1  0 0 0
0  0 0 1

Multiply this by the matrix

0 -1  0 0
0  0 -1 0
1  0  0 0
0  0  0 1

Multiply this by the matrix

0  0 1 0
0 -1 0 0
1  0 0 0
0  0 0 1

Multiply this by the matrix

0  0 -1 0
0 -1  0 0
1  0  0 0
0  0  0 1

Multiply this by the matrix

-1 0  0 0
 0 1  0 0
 0 0 -1 0
 0 0  0 1

Multiply this by the matrix

-1 0 0 0
 0 0 1 0
 0 1 0 0
 0 0 0 1

Multiply this by the matrix

-1 0  0 0
 0 0 -1 0
 0 1  0 0
 0 0  0 1

Multiply this by the matrix

-1  0 0 0
 0 -1 0 0
 0  0 1 0
 0  0 0 1

Multiply this by the matrix

-1  0  0 0
 0 -1  0 0
 0  0 -1 0
 0  0  0 1

Multiply this by the matrix

-1  0 0 0
 0  0 1 0
 0 -1 0 0
 0  0 0 1

Multiply this by the matrix

-1  0  0 0
 0  0 -1 0
 0 -1  0 0
 0  0  0 1

Multiply this by the matrix

 0 1 0 0
-1 0 0 0
 0 0 1 0
 0 0 0 1

Multiply this by the matrix

 0 1  0 0
-1 0  0 0
 0 0 -1 0
 0 0  0 1

Multiply this by the matrix

 0 0 1 0
-1 0 0 0
 0 1 0 0
 0 0 0 1

Multiply this by the matrix

 0 0 -1 0
-1 0  0 0
 0 1  0 0
 0 0  0 1

Multiply this by the matrix

 0 -1 0 0
-1  0 0 0
 0  0 1 0
 0  0 0 1

Multiply this by the matrix

 0 -1  0 0
-1  0  0 0
 0  0 -1 0
 0  0  0 1

Multiply this by the matrix

 0  0 1 0
-1  0 0 0
 0 -1 0 0
 0  0 0 1

Multiply this by the matrix

 0  0 -1 0
-1  0  0 0
 0 -1  0 0
 0  0  0 1

Multiply this by the matrix

 0 1 0 0
 0 0 1 0
-1 0 0 0
 0 0 0 1

Multiply this by the matrix

 0 1  0 0
 0 0 -1 0
-1 0  0 0
 0 0  0 1

Multiply this by the matrix

 0 0 1 0
 0 1 0 0
-1 0 0 0
 0 0 0 1

Multiply this by the matrix

 0 0 -1 0
 0 1  0 0
-1 0  0 0
 0 0  0 1

Multiply this by the matrix

 0 -1 0 0
 0  0 1 0
-1  0 0 0
 0  0 0 1

Multiply this by the matrix

 0 -1  0 0
 0  0 -1 0
-1  0  0 0
 0  0  0 1

Multiply this by the matrix

 0  0 1 0
 0 -1 0 0
-1  0 0 0
 0  0 0 1

Multiply this by the matrix

 0  0 -1 0
 0 -1  0 0
-1  0  0 0
 0  0  0 1

Multiply this matrix by the supplied right matrix.

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!

Multiply this matrix by the matrix with the supplied elements.

If M is this matrix and R the right matrix whose elements are supplied via the parameters, the: then 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!