mirror of
https://github.com/Jozufozu/Flywheel.git
synced 2024-12-27 07:26:48 +01:00
a42c027b6f
- Fix Resources not being closed properly - Change versioning scheme to match Create - Add LICENSE to built jar - Fix mods.toml version sync - Move JOML code to non-src directory - Update Gradle - Organize imports
6289 lines
276 KiB
Java
6289 lines
276 KiB
Java
/*
|
|
* The MIT License
|
|
*
|
|
* Copyright (c) 2016-2021 JOML
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
package com.jozufozu.flywheel.repack.joml;
|
|
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.DoubleBuffer;
|
|
import java.nio.FloatBuffer;
|
|
import java.util.*;
|
|
|
|
/**
|
|
* Interface to a read-only view of a 4x4 matrix of double-precision floats.
|
|
*
|
|
* @author Kai Burjack
|
|
*/
|
|
public interface Matrix4dc {
|
|
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumPlane(int, Vector4d)}
|
|
* identifying the plane with equation <code>x=-1</code> when using the identity matrix.
|
|
*/
|
|
int PLANE_NX = 0;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumPlane(int, Vector4d)}
|
|
* identifying the plane with equation <code>x=1</code> when using the identity matrix.
|
|
*/
|
|
int PLANE_PX = 1;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumPlane(int, Vector4d)}
|
|
* identifying the plane with equation <code>y=-1</code> when using the identity matrix.
|
|
*/
|
|
int PLANE_NY = 2;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumPlane(int, Vector4d)}
|
|
* identifying the plane with equation <code>y=1</code> when using the identity matrix.
|
|
*/
|
|
int PLANE_PY = 3;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumPlane(int, Vector4d)}
|
|
* identifying the plane with equation <code>z=-1</code> when using the identity matrix.
|
|
*/
|
|
int PLANE_NZ = 4;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumPlane(int, Vector4d)}
|
|
* identifying the plane with equation <code>z=1</code> when using the identity matrix.
|
|
*/
|
|
int PLANE_PZ = 5;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumCorner(int, Vector3d)}
|
|
* identifying the corner <code>(-1, -1, -1)</code> when using the identity matrix.
|
|
*/
|
|
int CORNER_NXNYNZ = 0;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumCorner(int, Vector3d)}
|
|
* identifying the corner <code>(1, -1, -1)</code> when using the identity matrix.
|
|
*/
|
|
int CORNER_PXNYNZ = 1;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumCorner(int, Vector3d)}
|
|
* identifying the corner <code>(1, 1, -1)</code> when using the identity matrix.
|
|
*/
|
|
int CORNER_PXPYNZ = 2;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumCorner(int, Vector3d)}
|
|
* identifying the corner <code>(-1, 1, -1)</code> when using the identity matrix.
|
|
*/
|
|
int CORNER_NXPYNZ = 3;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumCorner(int, Vector3d)}
|
|
* identifying the corner <code>(1, -1, 1)</code> when using the identity matrix.
|
|
*/
|
|
int CORNER_PXNYPZ = 4;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumCorner(int, Vector3d)}
|
|
* identifying the corner <code>(-1, -1, 1)</code> when using the identity matrix.
|
|
*/
|
|
int CORNER_NXNYPZ = 5;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumCorner(int, Vector3d)}
|
|
* identifying the corner <code>(-1, 1, 1)</code> when using the identity matrix.
|
|
*/
|
|
int CORNER_NXPYPZ = 6;
|
|
/**
|
|
* Argument to the first parameter of {@link #frustumCorner(int, Vector3d)}
|
|
* identifying the corner <code>(1, 1, 1)</code> when using the identity matrix.
|
|
*/
|
|
int CORNER_PXPYPZ = 7;
|
|
|
|
/**
|
|
* Bit returned by {@link #properties()} to indicate that the matrix represents a perspective transformation.
|
|
*/
|
|
byte PROPERTY_PERSPECTIVE = 1<<0;
|
|
/**
|
|
* Bit returned by {@link #properties()} to indicate that the matrix represents an affine transformation.
|
|
*/
|
|
byte PROPERTY_AFFINE = 1<<1;
|
|
/**
|
|
* Bit returned by {@link #properties()} to indicate that the matrix represents the identity transformation.
|
|
*/
|
|
byte PROPERTY_IDENTITY = 1<<2;
|
|
/**
|
|
* Bit returned by {@link #properties()} to indicate that the matrix represents a pure translation transformation.
|
|
*/
|
|
byte PROPERTY_TRANSLATION = 1<<3;
|
|
/**
|
|
* Bit returned by {@link #properties()} to indicate that the upper-left 3x3 submatrix represents an orthogonal
|
|
* matrix (i.e. orthonormal basis). For practical reasons, this property also always implies
|
|
* {@link #PROPERTY_AFFINE} in this implementation.
|
|
*/
|
|
byte PROPERTY_ORTHONORMAL = 1<<4;
|
|
|
|
/**
|
|
* Return the assumed properties of this matrix. This is a bit-combination of
|
|
* {@link #PROPERTY_IDENTITY}, {@link #PROPERTY_AFFINE},
|
|
* {@link #PROPERTY_TRANSLATION} and {@link #PROPERTY_PERSPECTIVE}.
|
|
*
|
|
* @return the properties of the matrix
|
|
*/
|
|
int properties();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 0 and row 0.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m00();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 0 and row 1.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m01();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 0 and row 2.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m02();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 0 and row 3.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m03();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 1 and row 0.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m10();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 1 and row 1.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m11();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 1 and row 2.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m12();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 1 and row 3.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m13();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 2 and row 0.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m20();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 2 and row 1.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m21();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 2 and row 2.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m22();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 2 and row 3.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m23();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 3 and row 0.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m30();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 3 and row 1.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m31();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 3 and row 2.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m32();
|
|
|
|
/**
|
|
* Return the value of the matrix element at column 3 and row 3.
|
|
*
|
|
* @return the value of the matrix element
|
|
*/
|
|
double m33();
|
|
|
|
/**
|
|
* Multiply this matrix by the supplied <code>right</code> matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param right
|
|
* the right operand of the multiplication
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mul(Matrix4dc right, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix by the supplied <code>right</code> matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
* <p>
|
|
* This method neither assumes nor checks for any matrix properties of <code>this</code> or <code>right</code>
|
|
* and will always perform a complete 4x4 matrix multiplication. This method should only be used whenever the
|
|
* multiplied matrices do not have any properties for which there are optimized multiplication methods available.
|
|
*
|
|
* @param right
|
|
* the right operand of the matrix multiplication
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mul0(Matrix4dc right, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix by the matrix with the supplied elements and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix whose
|
|
* elements are supplied via the parameters, then the new matrix will be <code>M * R</code>.
|
|
* So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param r00
|
|
* the m00 element of the right matrix
|
|
* @param r01
|
|
* the m01 element of the right matrix
|
|
* @param r02
|
|
* the m02 element of the right matrix
|
|
* @param r03
|
|
* the m03 element of the right matrix
|
|
* @param r10
|
|
* the m10 element of the right matrix
|
|
* @param r11
|
|
* the m11 element of the right matrix
|
|
* @param r12
|
|
* the m12 element of the right matrix
|
|
* @param r13
|
|
* the m13 element of the right matrix
|
|
* @param r20
|
|
* the m20 element of the right matrix
|
|
* @param r21
|
|
* the m21 element of the right matrix
|
|
* @param r22
|
|
* the m22 element of the right matrix
|
|
* @param r23
|
|
* the m23 element of the right matrix
|
|
* @param r30
|
|
* the m30 element of the right matrix
|
|
* @param r31
|
|
* the m31 element of the right matrix
|
|
* @param r32
|
|
* the m32 element of the right matrix
|
|
* @param r33
|
|
* the m33 element of the right matrix
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mul(
|
|
double r00, double r01, double r02, double r03,
|
|
double r10, double r11, double r12, double r13,
|
|
double r20, double r21, double r22, double r23,
|
|
double r30, double r31, double r32, double r33, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix by the 3x3 matrix with the supplied elements expanded to a 4x4 matrix with
|
|
* all other matrix elements set to identity, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix whose
|
|
* elements are supplied via the parameters, then the new matrix will be <code>M * R</code>.
|
|
* So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param r00
|
|
* the m00 element of the right matrix
|
|
* @param r01
|
|
* the m01 element of the right matrix
|
|
* @param r02
|
|
* the m02 element of the right matrix
|
|
* @param r10
|
|
* the m10 element of the right matrix
|
|
* @param r11
|
|
* the m11 element of the right matrix
|
|
* @param r12
|
|
* the m12 element of the right matrix
|
|
* @param r20
|
|
* the m20 element of the right matrix
|
|
* @param r21
|
|
* the m21 element of the right matrix
|
|
* @param r22
|
|
* the m22 element of the right matrix
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return this
|
|
*/
|
|
Matrix4d mul3x3(
|
|
double r00, double r01, double r02,
|
|
double r10, double r11, double r12,
|
|
double r20, double r21, double r22, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply this matrix by the supplied <code>left</code> matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the <code>left</code> matrix,
|
|
* then the new matrix will be <code>L * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>L * M * v</code>, the
|
|
* transformation of <code>this</code> matrix will be applied first!
|
|
*
|
|
* @param left
|
|
* the left operand of the matrix multiplication
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mulLocal(Matrix4dc left, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply this matrix by the supplied <code>left</code> matrix, both of which are assumed to be {@link #isAffine() affine}, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes that <code>this</code> matrix and the given <code>left</code> matrix both represent an {@link #isAffine() affine} transformation
|
|
* (i.e. their last rows are equal to <code>(0, 0, 0, 1)</code>)
|
|
* and can be used to speed up matrix multiplication if the matrices only represent affine transformations, such as translation, rotation, scaling and shearing (in any combination).
|
|
* <p>
|
|
* This method will not modify either the last row of <code>this</code> or the last row of <code>left</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the <code>left</code> matrix,
|
|
* then the new matrix will be <code>L * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>L * M * v</code>, the
|
|
* transformation of <code>this</code> matrix will be applied first!
|
|
*
|
|
* @param left
|
|
* the left operand of the matrix multiplication (the last row is assumed to be <code>(0, 0, 0, 1)</code>)
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mulLocalAffine(Matrix4dc left, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix by the supplied <code>right</code> matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param right
|
|
* the right operand of the matrix multiplication
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mul(Matrix3x2dc right, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix by the supplied <code>right</code> matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param right
|
|
* the right operand of the matrix multiplication
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mul(Matrix3x2fc right, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix by the supplied <code>right</code> matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The last row of the <code>right</code> matrix is assumed to be <code>(0, 0, 0, 1)</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param right
|
|
* the right operand of the matrix multiplication
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mul(Matrix4x3dc right, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix by the supplied <code>right</code> matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The last row of the <code>right</code> matrix is assumed to be <code>(0, 0, 0, 1)</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param right
|
|
* the right operand of the matrix multiplication
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mul(Matrix4x3fc right, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix by the supplied parameter matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param right
|
|
* the right operand of the multiplication
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mul(Matrix4fc right, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply <code>this</code> symmetric perspective projection matrix by the supplied {@link #isAffine() affine} <code>view</code> matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>P</code> is <code>this</code> matrix and <code>V</code> the <code>view</code> matrix,
|
|
* then the new matrix will be <code>P * V</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>P * V * v</code>, the
|
|
* transformation of the <code>view</code> matrix will be applied first!
|
|
*
|
|
* @param view
|
|
* the {@link #isAffine() affine} matrix to multiply <code>this</code> symmetric perspective projection matrix by
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mulPerspectiveAffine(Matrix4dc view, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply <code>this</code> symmetric perspective projection matrix by the supplied <code>view</code> matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>P</code> is <code>this</code> matrix and <code>V</code> the <code>view</code> matrix,
|
|
* then the new matrix will be <code>P * V</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>P * V * v</code>, the
|
|
* transformation of the <code>view</code> matrix will be applied first!
|
|
*
|
|
* @param view
|
|
* the matrix to multiply <code>this</code> symmetric perspective projection matrix by
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mulPerspectiveAffine(Matrix4x3dc view, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix by the supplied <code>right</code> matrix, which is assumed to be {@link #isAffine() affine}, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes that the given <code>right</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>)
|
|
* and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination).
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param right
|
|
* the right operand of the matrix multiplication (the last row is assumed to be <code>(0, 0, 0, 1)</code>)
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mulAffineR(Matrix4dc right, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix by the supplied <code>right</code> matrix, both of which are assumed to be {@link #isAffine() affine}, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes that <code>this</code> matrix and the given <code>right</code> matrix both represent an {@link #isAffine() affine} transformation
|
|
* (i.e. their last rows are equal to <code>(0, 0, 0, 1)</code>)
|
|
* and can be used to speed up matrix multiplication if the matrices only represent affine transformations, such as translation, rotation, scaling and shearing (in any combination).
|
|
* <p>
|
|
* This method will not modify either the last row of <code>this</code> or the last row of <code>right</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param right
|
|
* the right operand of the matrix multiplication (the last row is assumed to be <code>(0, 0, 0, 1)</code>)
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mulAffine(Matrix4dc right, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply this matrix, which is assumed to only contain a translation, by the supplied <code>right</code> matrix, which is assumed to be {@link #isAffine() affine}, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes that <code>this</code> matrix only contains a translation, and that the given <code>right</code> matrix represents an {@link #isAffine() affine} transformation
|
|
* (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>).
|
|
* <p>
|
|
* This method will not modify either the last row of <code>this</code> or the last row of <code>right</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* transformation of the right matrix will be applied first!
|
|
*
|
|
* @param right
|
|
* the right operand of the matrix multiplication (the last row is assumed to be <code>(0, 0, 0, 1)</code>)
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mulTranslationAffine(Matrix4dc right, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply <code>this</code> orthographic projection matrix by the supplied {@link #isAffine() affine} <code>view</code> matrix
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>V</code> the <code>view</code> matrix,
|
|
* then the new matrix will be <code>M * V</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * V * v</code>, the
|
|
* transformation of the <code>view</code> matrix will be applied first!
|
|
*
|
|
* @param view
|
|
* the affine matrix which to multiply <code>this</code> with
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mulOrthoAffine(Matrix4dc view, Matrix4d dest);
|
|
|
|
/**
|
|
* Component-wise add the upper 4x3 submatrices of <code>this</code> and <code>other</code>
|
|
* by first multiplying each component of <code>other</code>'s 4x3 submatrix by <code>otherFactor</code>,
|
|
* adding that to <code>this</code> and storing the final result in <code>dest</code>.
|
|
* <p>
|
|
* The other components of <code>dest</code> will be set to the ones of <code>this</code>.
|
|
* <p>
|
|
* The matrices <code>this</code> and <code>other</code> will not be changed.
|
|
*
|
|
* @param other
|
|
* the other matrix
|
|
* @param otherFactor
|
|
* the factor to multiply each of the other matrix's 4x3 components
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d fma4x3(Matrix4dc other, double otherFactor, Matrix4d dest);
|
|
|
|
/**
|
|
* Component-wise add <code>this</code> and <code>other</code> and store the result in <code>dest</code>.
|
|
*
|
|
* @param other
|
|
* the other addend
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d add(Matrix4dc other, Matrix4d dest);
|
|
|
|
/**
|
|
* Component-wise subtract <code>subtrahend</code> from <code>this</code> and store the result in <code>dest</code>.
|
|
*
|
|
* @param subtrahend
|
|
* the subtrahend
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d sub(Matrix4dc subtrahend, Matrix4d dest);
|
|
|
|
/**
|
|
* Component-wise multiply <code>this</code> by <code>other</code> and store the result in <code>dest</code>.
|
|
*
|
|
* @param other
|
|
* the other matrix
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mulComponentWise(Matrix4dc other, Matrix4d dest);
|
|
|
|
/**
|
|
* Component-wise add the upper 4x3 submatrices of <code>this</code> and <code>other</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The other components of <code>dest</code> will be set to the ones of <code>this</code>.
|
|
*
|
|
* @param other
|
|
* the other addend
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d add4x3(Matrix4dc other, Matrix4d dest);
|
|
|
|
/**
|
|
* Component-wise add the upper 4x3 submatrices of <code>this</code> and <code>other</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The other components of <code>dest</code> will be set to the ones of <code>this</code>.
|
|
*
|
|
* @param other
|
|
* the other addend
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d add4x3(Matrix4fc other, Matrix4d dest);
|
|
|
|
/**
|
|
* Component-wise subtract the upper 4x3 submatrices of <code>subtrahend</code> from <code>this</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The other components of <code>dest</code> will be set to the ones of <code>this</code>.
|
|
*
|
|
* @param subtrahend
|
|
* the subtrahend
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d sub4x3(Matrix4dc subtrahend, Matrix4d dest);
|
|
|
|
/**
|
|
* Component-wise multiply the upper 4x3 submatrices of <code>this</code> by <code>other</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The other components of <code>dest</code> will be set to the ones of <code>this</code>.
|
|
*
|
|
* @param other
|
|
* the other matrix
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mul4x3ComponentWise(Matrix4dc other, Matrix4d dest);
|
|
|
|
/**
|
|
* Return the determinant of this matrix.
|
|
* <p>
|
|
* If <code>this</code> matrix represents an {@link #isAffine() affine} transformation, such as translation, rotation, scaling and shearing,
|
|
* and thus its last row is equal to <code>(0, 0, 0, 1)</code>, then {@link #determinantAffine()} can be used instead of this method.
|
|
*
|
|
* @see #determinantAffine()
|
|
*
|
|
* @return the determinant
|
|
*/
|
|
double determinant();
|
|
|
|
/**
|
|
* Return the determinant of the upper left 3x3 submatrix of this matrix.
|
|
*
|
|
* @return the determinant
|
|
*/
|
|
double determinant3x3();
|
|
|
|
/**
|
|
* Return the determinant of this matrix by assuming that it represents an {@link #isAffine() affine} transformation and thus
|
|
* its last row is equal to <code>(0, 0, 0, 1)</code>.
|
|
*
|
|
* @return the determinant
|
|
*/
|
|
double determinantAffine();
|
|
|
|
/**
|
|
* Invert <code>this</code> matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>this</code> matrix represents an {@link #isAffine() affine} transformation, such as translation, rotation, scaling and shearing,
|
|
* and thus its last row is equal to <code>(0, 0, 0, 1)</code>, then {@link #invertAffine(Matrix4d)} can be used instead of this method.
|
|
*
|
|
* @see #invertAffine(Matrix4d)
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d invert(Matrix4d dest);
|
|
|
|
/**
|
|
* If <code>this</code> is a perspective projection matrix obtained via one of the {@link #perspective(double, double, double, double, Matrix4d) perspective()} methods,
|
|
* that is, if <code>this</code> is a symmetrical perspective frustum transformation,
|
|
* then this method builds the inverse of <code>this</code> and stores it into the given <code>dest</code>.
|
|
* <p>
|
|
* 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, Matrix4d) perspective()}.
|
|
*
|
|
* @see #perspective(double, double, double, double, Matrix4d)
|
|
*
|
|
* @param dest
|
|
* will hold the inverse of <code>this</code>
|
|
* @return dest
|
|
*/
|
|
Matrix4d invertPerspective(Matrix4d dest);
|
|
|
|
/**
|
|
* If <code>this</code> is an arbitrary perspective projection matrix obtained via one of the {@link #frustum(double, double, double, double, double, double, Matrix4d) frustum()} methods,
|
|
* then this method builds the inverse of <code>this</code> and stores it into the given <code>dest</code>.
|
|
* <p>
|
|
* This method can be used to quickly obtain the inverse of a perspective projection matrix.
|
|
* <p>
|
|
* If this matrix represents a symmetric perspective frustum transformation, as obtained via {@link #perspective(double, double, double, double, Matrix4d) perspective()}, then
|
|
* {@link #invertPerspective(Matrix4d)} should be used instead.
|
|
*
|
|
* @see #frustum(double, double, double, double, double, double, Matrix4d)
|
|
* @see #invertPerspective(Matrix4d)
|
|
*
|
|
* @param dest
|
|
* will hold the inverse of <code>this</code>
|
|
* @return dest
|
|
*/
|
|
Matrix4d invertFrustum(Matrix4d dest);
|
|
|
|
/**
|
|
* Invert <code>this</code> orthographic projection matrix and store the result into the given <code>dest</code>.
|
|
* <p>
|
|
* This method can be used to quickly obtain the inverse of an orthographic projection matrix.
|
|
*
|
|
* @param dest
|
|
* will hold the inverse of <code>this</code>
|
|
* @return dest
|
|
*/
|
|
Matrix4d invertOrtho(Matrix4d dest);
|
|
|
|
/**
|
|
* If <code>this</code> is a perspective projection matrix obtained via one of the {@link #perspective(double, double, double, double, Matrix4d) perspective()} methods,
|
|
* that is, if <code>this</code> is a symmetrical perspective frustum transformation
|
|
* and the given <code>view</code> matrix is {@link #isAffine() affine} and has unit scaling (for example by being obtained via {@link #lookAt(double, double, double, double, double, double, double, double, double, Matrix4d) lookAt()}),
|
|
* then this method builds the inverse of <code>this * view</code> and stores it into the given <code>dest</code>.
|
|
* <p>
|
|
* This method can be used to quickly obtain the inverse of the combination of the view and projection matrices, when both were obtained
|
|
* via the common methods {@link #perspective(double, double, double, double, Matrix4d) perspective()} and {@link #lookAt(double, double, double, double, double, double, double, double, double, Matrix4d) lookAt()} or
|
|
* other methods, that build affine matrices, such as {@link #translate(double, double, double, Matrix4d) translate} and {@link #rotate(double, double, double, double, Matrix4d)}, except for {@link #scale(double, double, double, Matrix4d) scale()}.
|
|
* <p>
|
|
* For the special cases of the matrices <code>this</code> and <code>view</code> mentioned above, this method is equivalent to the following code:
|
|
* <pre>
|
|
* dest.set(this).mul(view).invert();
|
|
* </pre>
|
|
*
|
|
* @param view
|
|
* the view transformation (must be {@link #isAffine() affine} and have unit scaling)
|
|
* @param dest
|
|
* will hold the inverse of <code>this * view</code>
|
|
* @return dest
|
|
*/
|
|
Matrix4d invertPerspectiveView(Matrix4dc view, Matrix4d dest);
|
|
|
|
/**
|
|
* If <code>this</code> is a perspective projection matrix obtained via one of the {@link #perspective(double, double, double, double, Matrix4d) perspective()} methods,
|
|
* that is, if <code>this</code> is a symmetrical perspective frustum transformation
|
|
* and the given <code>view</code> matrix has unit scaling,
|
|
* then this method builds the inverse of <code>this * view</code> and stores it into the given <code>dest</code>.
|
|
* <p>
|
|
* This method can be used to quickly obtain the inverse of the combination of the view and projection matrices, when both were obtained
|
|
* via the common methods {@link #perspective(double, double, double, double, Matrix4d) perspective()} and {@link #lookAt(double, double, double, double, double, double, double, double, double, Matrix4d) lookAt()} or
|
|
* other methods, that build affine matrices, such as {@link #translate(double, double, double, Matrix4d) translate} and {@link #rotate(double, double, double, double, Matrix4d)}, except for {@link #scale(double, double, double, Matrix4d) scale()}.
|
|
* <p>
|
|
* For the special cases of the matrices <code>this</code> and <code>view</code> mentioned above, this method is equivalent to the following code:
|
|
* <pre>
|
|
* dest.set(this).mul(view).invert();
|
|
* </pre>
|
|
*
|
|
* @param view
|
|
* the view transformation (must have unit scaling)
|
|
* @param dest
|
|
* will hold the inverse of <code>this * view</code>
|
|
* @return dest
|
|
*/
|
|
Matrix4d invertPerspectiveView(Matrix4x3dc view, Matrix4d dest);
|
|
|
|
/**
|
|
* Invert this matrix by assuming that it is an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>)
|
|
* and write the result into <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d invertAffine(Matrix4d dest);
|
|
|
|
/**
|
|
* Transpose <code>this</code> matrix and store the result into <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d transpose(Matrix4d dest);
|
|
|
|
/**
|
|
* Transpose only the upper left 3x3 submatrix of this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* All other matrix elements are left unchanged.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d transpose3x3(Matrix4d dest);
|
|
|
|
/**
|
|
* Transpose only the upper left 3x3 submatrix of this matrix and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix3d transpose3x3(Matrix3d dest);
|
|
|
|
/**
|
|
* Get only the translation components <code>(m30, m31, m32)</code> of this matrix and store them in the given vector <code>xyz</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the translation components of this matrix
|
|
* @return dest
|
|
*/
|
|
Vector3d getTranslation(Vector3d dest);
|
|
|
|
/**
|
|
* Get the scaling factors of <code>this</code> matrix for the three base axes.
|
|
*
|
|
* @param dest
|
|
* will hold the scaling factors for <code>x</code>, <code>y</code> and <code>z</code>
|
|
* @return dest
|
|
*/
|
|
Vector3d getScale(Vector3d dest);
|
|
|
|
/**
|
|
* Get the current values of <code>this</code> matrix and store them into
|
|
* <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* the destination matrix
|
|
* @return the passed in destination
|
|
*/
|
|
Matrix4d get(Matrix4d dest);
|
|
|
|
/**
|
|
* Get the current values of the upper 4x3 submatrix of <code>this</code> matrix and store them into
|
|
* <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* the destination matrix
|
|
* @return the passed in destination
|
|
*/
|
|
Matrix4x3d get4x3(Matrix4x3d dest);
|
|
|
|
/**
|
|
* Get the current values of the upper left 3x3 submatrix of <code>this</code> matrix and store them into
|
|
* <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* the destination matrix
|
|
* @return the passed in destination
|
|
*/
|
|
Matrix3d get3x3(Matrix3d dest);
|
|
|
|
/**
|
|
* Get the current values of <code>this</code> matrix and store the represented rotation
|
|
* into the given {@link Quaternionf}.
|
|
* <p>
|
|
* This method assumes that the first three column vectors of the upper left 3x3 submatrix are not normalized and
|
|
* thus allows to ignore any additional scaling factor that is applied to the matrix.
|
|
*
|
|
* @see Quaternionf#setFromUnnormalized(Matrix4dc)
|
|
*
|
|
* @param dest
|
|
* the destination {@link Quaternionf}
|
|
* @return the passed in destination
|
|
*/
|
|
Quaternionf getUnnormalizedRotation(Quaternionf dest);
|
|
|
|
/**
|
|
* Get the current values of <code>this</code> matrix and store the represented rotation
|
|
* into the given {@link Quaternionf}.
|
|
* <p>
|
|
* This method assumes that the first three column vectors of the upper left 3x3 submatrix are normalized.
|
|
*
|
|
* @see Quaternionf#setFromNormalized(Matrix4dc)
|
|
*
|
|
* @param dest
|
|
* the destination {@link Quaternionf}
|
|
* @return the passed in destination
|
|
*/
|
|
Quaternionf getNormalizedRotation(Quaternionf dest);
|
|
|
|
/**
|
|
* Get the current values of <code>this</code> matrix and store the represented rotation
|
|
* into the given {@link Quaterniond}.
|
|
* <p>
|
|
* This method assumes that the first three column vectors of the upper left 3x3 submatrix are not normalized and
|
|
* thus allows to ignore any additional scaling factor that is applied to the matrix.
|
|
*
|
|
* @see Quaterniond#setFromUnnormalized(Matrix4dc)
|
|
*
|
|
* @param dest
|
|
* the destination {@link Quaterniond}
|
|
* @return the passed in destination
|
|
*/
|
|
Quaterniond getUnnormalizedRotation(Quaterniond dest);
|
|
|
|
/**
|
|
* Get the current values of <code>this</code> matrix and store the represented rotation
|
|
* into the given {@link Quaterniond}.
|
|
* <p>
|
|
* This method assumes that the first three column vectors of the upper left 3x3 submatrix are normalized.
|
|
*
|
|
* @see Quaterniond#setFromNormalized(Matrix4dc)
|
|
*
|
|
* @param dest
|
|
* the destination {@link Quaterniond}
|
|
* @return the passed in destination
|
|
*/
|
|
Quaterniond getNormalizedRotation(Quaterniond dest);
|
|
|
|
/**
|
|
* Store this matrix in column-major order into the supplied {@link DoubleBuffer} at the current
|
|
* buffer {@link DoubleBuffer#position() position}.
|
|
* <p>
|
|
* This method will not increment the position of the given DoubleBuffer.
|
|
* <p>
|
|
* In order to specify the offset into the DoubleBuffer at which
|
|
* the matrix is stored, use {@link #get(int, DoubleBuffer)}, taking
|
|
* the absolute position as parameter.
|
|
*
|
|
* @see #get(int, DoubleBuffer)
|
|
*
|
|
* @param buffer
|
|
* will receive the values of this matrix in column-major order at its current position
|
|
* @return the passed in buffer
|
|
*/
|
|
DoubleBuffer get(DoubleBuffer buffer);
|
|
|
|
/**
|
|
* Store this matrix in column-major order into the supplied {@link DoubleBuffer} starting at the specified
|
|
* absolute buffer position/index.
|
|
* <p>
|
|
* This method will not increment the position of the given {@link DoubleBuffer}.
|
|
*
|
|
* @param index
|
|
* the absolute position into the {@link DoubleBuffer}
|
|
* @param buffer
|
|
* will receive the values of this matrix in column-major order
|
|
* @return the passed in buffer
|
|
*/
|
|
DoubleBuffer get(int index, DoubleBuffer buffer);
|
|
|
|
/**
|
|
* Store this matrix in column-major order into the supplied {@link FloatBuffer} at the current
|
|
* buffer {@link FloatBuffer#position() position}.
|
|
* <p>
|
|
* This method will not increment the position of the given
|
|
* FloatBuffer.
|
|
* <p>
|
|
* In order to specify the offset into the FloatBuffer at which
|
|
* the matrix is stored, use {@link #get(int, FloatBuffer)}, taking
|
|
* the absolute position as parameter.
|
|
* <p>
|
|
* 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.
|
|
*
|
|
* @see #get(int, FloatBuffer)
|
|
*
|
|
* @param buffer
|
|
* will receive the values of this matrix in column-major order at its current position
|
|
* @return the passed in buffer
|
|
*/
|
|
FloatBuffer get(FloatBuffer buffer);
|
|
|
|
/**
|
|
* Store this matrix in column-major order into the supplied {@link FloatBuffer} starting at the specified
|
|
* absolute buffer position/index.
|
|
* <p>
|
|
* This method will not increment the position of the given FloatBuffer.
|
|
* <p>
|
|
* 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.
|
|
*
|
|
* @param index
|
|
* the absolute position into the FloatBuffer
|
|
* @param buffer
|
|
* will receive the values of this matrix in column-major order
|
|
* @return the passed in buffer
|
|
*/
|
|
FloatBuffer get(int index, FloatBuffer buffer);
|
|
|
|
/**
|
|
* Store this matrix in column-major order into the supplied {@link ByteBuffer} at the current
|
|
* buffer {@link ByteBuffer#position() position}.
|
|
* <p>
|
|
* This method will not increment the position of the given ByteBuffer.
|
|
* <p>
|
|
* In order to specify the offset into the ByteBuffer at which
|
|
* the matrix is stored, use {@link #get(int, ByteBuffer)}, taking
|
|
* the absolute position as parameter.
|
|
*
|
|
* @see #get(int, ByteBuffer)
|
|
*
|
|
* @param buffer
|
|
* will receive the values of this matrix in column-major order at its current position
|
|
* @return the passed in buffer
|
|
*/
|
|
ByteBuffer get(ByteBuffer buffer);
|
|
|
|
/**
|
|
* Store this matrix in column-major order into the supplied {@link ByteBuffer} starting at the specified
|
|
* absolute buffer position/index.
|
|
* <p>
|
|
* This method will not increment the position of the given ByteBuffer.
|
|
*
|
|
* @param index
|
|
* the absolute position into the ByteBuffer
|
|
* @param buffer
|
|
* will receive the values of this matrix in column-major order
|
|
* @return the passed in buffer
|
|
*/
|
|
ByteBuffer get(int index, ByteBuffer buffer);
|
|
|
|
/**
|
|
* Store this matrix in column-major order at the given off-heap address.
|
|
* <p>
|
|
* This method will throw an {@link UnsupportedOperationException} when JOML is used with `-Djoml.nounsafe`.
|
|
* <p>
|
|
* <em>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.</em>
|
|
*
|
|
* @param address
|
|
* the off-heap address where to store this matrix
|
|
* @return this
|
|
*/
|
|
Matrix4dc getToAddress(long address);
|
|
|
|
/**
|
|
* Store the elements of this matrix as float values in column-major order into the supplied {@link ByteBuffer} at the current
|
|
* buffer {@link ByteBuffer#position() position}.
|
|
* <p>
|
|
* This method will not increment the position of the given ByteBuffer.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* In order to specify the offset into the ByteBuffer at which
|
|
* the matrix is stored, use {@link #getFloats(int, ByteBuffer)}, taking
|
|
* the absolute position as parameter.
|
|
*
|
|
* @see #getFloats(int, ByteBuffer)
|
|
*
|
|
* @param buffer
|
|
* will receive the elements of this matrix as float values in column-major order at its current position
|
|
* @return the passed in buffer
|
|
*/
|
|
ByteBuffer getFloats(ByteBuffer buffer);
|
|
|
|
/**
|
|
* Store the elements of this matrix as float values in column-major order into the supplied {@link ByteBuffer}
|
|
* starting at the specified absolute buffer position/index.
|
|
* <p>
|
|
* This method will not increment the position of the given ByteBuffer.
|
|
* <p>
|
|
* 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.
|
|
*
|
|
* @param index
|
|
* the absolute position into the ByteBuffer
|
|
* @param buffer
|
|
* will receive the elements of this matrix as float values in column-major order
|
|
* @return the passed in buffer
|
|
*/
|
|
ByteBuffer getFloats(int index, ByteBuffer buffer);
|
|
|
|
/**
|
|
* Store this matrix into the supplied double array in column-major order at the given offset.
|
|
*
|
|
* @param arr
|
|
* the array to write the matrix values into
|
|
* @param offset
|
|
* the offset into the array
|
|
* @return the passed in array
|
|
*/
|
|
double[] get(double[] arr, int offset);
|
|
|
|
/**
|
|
* Store this matrix into the supplied double array in column-major order.
|
|
* <p>
|
|
* In order to specify an explicit offset into the array, use the method {@link #get(double[], int)}.
|
|
*
|
|
* @see #get(double[], int)
|
|
*
|
|
* @param arr
|
|
* the array to write the matrix values into
|
|
* @return the passed in array
|
|
*/
|
|
double[] get(double[] arr);
|
|
|
|
/**
|
|
* Store the elements of this matrix as float values in column-major order into the supplied float array at the given offset.
|
|
* <p>
|
|
* 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.
|
|
*
|
|
* @param arr
|
|
* the array to write the matrix values into
|
|
* @param offset
|
|
* the offset into the array
|
|
* @return the passed in 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.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* In order to specify an explicit offset into the array, use the method {@link #get(float[], int)}.
|
|
*
|
|
* @see #get(float[], int)
|
|
*
|
|
* @param arr
|
|
* the array to write the matrix values into
|
|
* @return the passed in array
|
|
*/
|
|
float[] get(float[] arr);
|
|
|
|
/**
|
|
* Store the transpose of this matrix in column-major order into the supplied {@link DoubleBuffer} at the current
|
|
* buffer {@link DoubleBuffer#position() position}.
|
|
* <p>
|
|
* This method will not increment the position of the given DoubleBuffer.
|
|
* <p>
|
|
* In order to specify the offset into the DoubleBuffer at which
|
|
* the matrix is stored, use {@link #getTransposed(int, DoubleBuffer)}, taking
|
|
* the absolute position as parameter.
|
|
*
|
|
* @see #getTransposed(int, DoubleBuffer)
|
|
*
|
|
* @param buffer
|
|
* will receive the values of this matrix in column-major order at its current position
|
|
* @return the passed in buffer
|
|
*/
|
|
DoubleBuffer getTransposed(DoubleBuffer buffer);
|
|
|
|
/**
|
|
* Store the transpose of this matrix in column-major order into the supplied {@link DoubleBuffer} starting at the specified
|
|
* absolute buffer position/index.
|
|
* <p>
|
|
* This method will not increment the position of the given DoubleBuffer.
|
|
*
|
|
* @param index
|
|
* the absolute position into the DoubleBuffer
|
|
* @param buffer
|
|
* will receive the values of this matrix in column-major order
|
|
* @return the passed in buffer
|
|
*/
|
|
DoubleBuffer getTransposed(int index, DoubleBuffer buffer);
|
|
|
|
/**
|
|
* Store the transpose of this matrix in column-major order into the supplied {@link ByteBuffer} at the current
|
|
* buffer {@link ByteBuffer#position() position}.
|
|
* <p>
|
|
* This method will not increment the position of the given ByteBuffer.
|
|
* <p>
|
|
* In order to specify the offset into the ByteBuffer at which
|
|
* the matrix is stored, use {@link #getTransposed(int, ByteBuffer)}, taking
|
|
* the absolute position as parameter.
|
|
*
|
|
* @see #getTransposed(int, ByteBuffer)
|
|
*
|
|
* @param buffer
|
|
* will receive the values of this matrix in column-major order at its current position
|
|
* @return the passed in buffer
|
|
*/
|
|
ByteBuffer getTransposed(ByteBuffer buffer);
|
|
|
|
/**
|
|
* Store the transpose of this matrix in column-major order into the supplied {@link ByteBuffer} starting at the specified
|
|
* absolute buffer position/index.
|
|
* <p>
|
|
* This method will not increment the position of the given ByteBuffer.
|
|
*
|
|
* @param index
|
|
* the absolute position into the ByteBuffer
|
|
* @param buffer
|
|
* will receive the values of this matrix in column-major order
|
|
* @return the passed in buffer
|
|
*/
|
|
ByteBuffer getTransposed(int index, ByteBuffer buffer);
|
|
|
|
/**
|
|
* Store the upper 4x3 submatrix of <code>this</code> matrix in row-major order into the supplied {@link DoubleBuffer} at the current
|
|
* buffer {@link DoubleBuffer#position() position}.
|
|
* <p>
|
|
* This method will not increment the position of the given DoubleBuffer.
|
|
* <p>
|
|
* In order to specify the offset into the DoubleBuffer at which
|
|
* the matrix is stored, use {@link #get4x3Transposed(int, DoubleBuffer)}, taking
|
|
* the absolute position as parameter.
|
|
*
|
|
* @see #get4x3Transposed(int, DoubleBuffer)
|
|
*
|
|
* @param buffer
|
|
* will receive the values of the upper 4x3 submatrix in row-major order at its current position
|
|
* @return the passed in buffer
|
|
*/
|
|
DoubleBuffer get4x3Transposed(DoubleBuffer buffer);
|
|
|
|
/**
|
|
* Store the upper 4x3 submatrix of <code>this</code> matrix in row-major order into the supplied {@link DoubleBuffer} starting at the specified
|
|
* absolute buffer position/index.
|
|
* <p>
|
|
* This method will not increment the position of the given DoubleBuffer.
|
|
*
|
|
* @param index
|
|
* the absolute position into the DoubleBuffer
|
|
* @param buffer
|
|
* will receive the values of the upper 4x3 submatrix in row-major order
|
|
* @return the passed in buffer
|
|
*/
|
|
DoubleBuffer get4x3Transposed(int index, DoubleBuffer buffer);
|
|
|
|
/**
|
|
* Store the upper 4x3 submatrix of <code>this</code> matrix in row-major order into the supplied {@link ByteBuffer} at the current
|
|
* buffer {@link ByteBuffer#position() position}.
|
|
* <p>
|
|
* This method will not increment the position of the given ByteBuffer.
|
|
* <p>
|
|
* In order to specify the offset into the ByteBuffer at which
|
|
* the matrix is stored, use {@link #get4x3Transposed(int, ByteBuffer)}, taking
|
|
* the absolute position as parameter.
|
|
*
|
|
* @see #get4x3Transposed(int, ByteBuffer)
|
|
*
|
|
* @param buffer
|
|
* will receive the values of the upper 4x3 submatrix in row-major order at its current position
|
|
* @return the passed in buffer
|
|
*/
|
|
ByteBuffer get4x3Transposed(ByteBuffer buffer);
|
|
|
|
/**
|
|
* Store the upper 4x3 submatrix of <code>this</code> matrix in row-major order into the supplied {@link ByteBuffer} starting at the specified
|
|
* absolute buffer position/index.
|
|
* <p>
|
|
* This method will not increment the position of the given ByteBuffer.
|
|
*
|
|
* @param index
|
|
* the absolute position into the ByteBuffer
|
|
* @param buffer
|
|
* will receive the values of the upper 4x3 submatrix in row-major order
|
|
* @return the passed in buffer
|
|
*/
|
|
ByteBuffer get4x3Transposed(int index, ByteBuffer buffer);
|
|
|
|
/**
|
|
* Transform/multiply the given vector by this matrix and store the result in that vector.
|
|
*
|
|
* @see Vector4d#mul(Matrix4dc)
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @return v
|
|
*/
|
|
Vector4d transform(Vector4d v);
|
|
|
|
/**
|
|
* Transform/multiply the given vector by this matrix and store the result in <code>dest</code>.
|
|
*
|
|
* @see Vector4d#mul(Matrix4dc, Vector4d)
|
|
*
|
|
* @param v
|
|
* the vector to transform
|
|
* @param dest
|
|
* will contain the result
|
|
* @return dest
|
|
*/
|
|
Vector4d transform(Vector4dc v, Vector4d dest);
|
|
|
|
/**
|
|
* Transform/multiply the vector <code>(x, y, z, w)</code> by this matrix and store the result in <code>dest</code>.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the vector to transform
|
|
* @param y
|
|
* the y coordinate of the vector to transform
|
|
* @param z
|
|
* the z coordinate of the vector to transform
|
|
* @param w
|
|
* the w coordinate of the vector to transform
|
|
* @param dest
|
|
* will contain the result
|
|
* @return dest
|
|
*/
|
|
Vector4d transform(double x, double y, double z, double w, Vector4d dest);
|
|
|
|
/**
|
|
* Transform/multiply the given vector by the transpose of this matrix and store the result in that vector.
|
|
*
|
|
* @see Vector4d#mulTranspose(Matrix4dc)
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @return v
|
|
*/
|
|
Vector4d transformTranspose(Vector4d v);
|
|
|
|
/**
|
|
* Transform/multiply the given vector by the transpose of this matrix and store the result in <code>dest</code>.
|
|
*
|
|
* @see Vector4d#mulTranspose(Matrix4dc)
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @param dest
|
|
* will contain the result
|
|
* @return dest
|
|
*/
|
|
Vector4d transformTranspose(Vector4dc v, Vector4d dest);
|
|
|
|
/**
|
|
* Transform/multiply the vector <code>(x, y, z, w)</code> by the transpose of this matrix
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the vector to transform
|
|
* @param y
|
|
* the y coordinate of the vector to transform
|
|
* @param z
|
|
* the z coordinate of the vector to transform
|
|
* @param w
|
|
* the w coordinate of the vector to transform
|
|
* @param dest
|
|
* will contain the result
|
|
* @return dest
|
|
*/
|
|
Vector4d transformTranspose(double x, double y, double z, double w, Vector4d dest);
|
|
|
|
/**
|
|
* Transform/multiply the given vector by this matrix, perform perspective divide and store the result in that vector.
|
|
*
|
|
* @see Vector4d#mulProject(Matrix4dc)
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @return v
|
|
*/
|
|
Vector4d transformProject(Vector4d v);
|
|
|
|
/**
|
|
* Transform/multiply the given vector by this matrix, perform perspective divide and store the result in <code>dest</code>.
|
|
*
|
|
* @see Vector4d#mulProject(Matrix4dc, Vector4d)
|
|
*
|
|
* @param v
|
|
* the vector to transform
|
|
* @param dest
|
|
* will contain the result
|
|
* @return dest
|
|
*/
|
|
Vector4d transformProject(Vector4dc v, Vector4d dest);
|
|
|
|
/**
|
|
* Transform/multiply the given vector by this matrix, perform perspective divide
|
|
* and store the <code>x</code>, <code>y</code> and <code>z</code> components of the
|
|
* result in <code>dest</code>.
|
|
*
|
|
* @see Vector3d#mulProject(Matrix4dc, Vector3d)
|
|
*
|
|
* @param v
|
|
* the vector to transform
|
|
* @param dest
|
|
* will contain the result
|
|
* @return dest
|
|
*/
|
|
Vector3d transformProject(Vector4dc v, Vector3d dest);
|
|
|
|
/**
|
|
* Transform/multiply the vector <code>(x, y, z, w)</code> by this matrix, perform perspective divide and store the result in <code>dest</code>.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the direction to transform
|
|
* @param y
|
|
* the y coordinate of the direction to transform
|
|
* @param z
|
|
* the z coordinate of the direction to transform
|
|
* @param w
|
|
* the w coordinate of the direction to transform
|
|
* @param dest
|
|
* will contain the result
|
|
* @return dest
|
|
*/
|
|
Vector4d transformProject(double x, double y, double z, double w, Vector4d dest);
|
|
|
|
/**
|
|
* Transform/multiply the given vector by this matrix, perform perspective divide and store the result in that vector.
|
|
* <p>
|
|
* This method uses <code>w=1.0</code> as the fourth vector component.
|
|
*
|
|
* @see Vector3d#mulProject(Matrix4dc)
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @return v
|
|
*/
|
|
Vector3d transformProject(Vector3d v);
|
|
|
|
/**
|
|
* Transform/multiply the given vector by this matrix, perform perspective divide and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method uses <code>w=1.0</code> as the fourth vector component.
|
|
*
|
|
* @see Vector3d#mulProject(Matrix4dc, Vector3d)
|
|
*
|
|
* @param v
|
|
* the vector to transform
|
|
* @param dest
|
|
* will contain the result
|
|
* @return dest
|
|
*/
|
|
Vector3d transformProject(Vector3dc v, Vector3d dest);
|
|
|
|
/**
|
|
* Transform/multiply the vector <code>(x, y, z)</code> by this matrix, perform perspective divide and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method uses <code>w=1.0</code> as the fourth vector component.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the vector to transform
|
|
* @param y
|
|
* the y coordinate of the vector to transform
|
|
* @param z
|
|
* the z coordinate of the vector to transform
|
|
* @param dest
|
|
* will contain the result
|
|
* @return dest
|
|
*/
|
|
Vector3d transformProject(double x, double y, double z, Vector3d dest);
|
|
|
|
/**
|
|
* Transform/multiply the vector <code>(x, y, z, w)</code> by this matrix, perform perspective divide and store
|
|
* <code>(x, y, z)</code> of the result in <code>dest</code>.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the vector to transform
|
|
* @param y
|
|
* the y coordinate of the vector to transform
|
|
* @param z
|
|
* the z coordinate of the vector to transform
|
|
* @param w
|
|
* the w coordinate of the vector to transform
|
|
* @param dest
|
|
* will contain the <code>(x, y, z)</code> components of the result
|
|
* @return dest
|
|
*/
|
|
Vector3d transformProject(double x, double y, double z, double w, Vector3d dest);
|
|
|
|
/**
|
|
* Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=1, by
|
|
* this matrix and store the result in that vector.
|
|
* <p>
|
|
* The given 3D-vector is treated as a 4D-vector with its w-component being 1.0, so it
|
|
* will represent a position/location in 3D-space rather than a direction. This method is therefore
|
|
* not suited for perspective projection transformations as it will not save the
|
|
* <code>w</code> component of the transformed vector.
|
|
* For perspective projection use {@link #transform(Vector4d)} or
|
|
* {@link #transformProject(Vector3d)} when perspective divide should be applied, too.
|
|
* <p>
|
|
* In order to store the result in another vector, use {@link #transformPosition(Vector3dc, Vector3d)}.
|
|
*
|
|
* @see #transformPosition(Vector3dc, Vector3d)
|
|
* @see #transform(Vector4d)
|
|
* @see #transformProject(Vector3d)
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @return v
|
|
*/
|
|
Vector3d transformPosition(Vector3d v);
|
|
|
|
/**
|
|
* Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=1, by
|
|
* this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The given 3D-vector is treated as a 4D-vector with its w-component being 1.0, so it
|
|
* will represent a position/location in 3D-space rather than a direction. This method is therefore
|
|
* not suited for perspective projection transformations as it will not save the
|
|
* <code>w</code> component of the transformed vector.
|
|
* For perspective projection use {@link #transform(Vector4dc, Vector4d)} or
|
|
* {@link #transformProject(Vector3dc, Vector3d)} when perspective divide should be applied, too.
|
|
* <p>
|
|
* In order to store the result in the same vector, use {@link #transformPosition(Vector3d)}.
|
|
*
|
|
* @see #transformPosition(Vector3d)
|
|
* @see #transform(Vector4dc, Vector4d)
|
|
* @see #transformProject(Vector3dc, Vector3d)
|
|
*
|
|
* @param v
|
|
* the vector to transform
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Vector3d transformPosition(Vector3dc v, Vector3d dest);
|
|
|
|
/**
|
|
* Transform/multiply the 3D-vector <code>(x, y, z)</code>, as if it was a 4D-vector with w=1, by
|
|
* this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The given 3D-vector is treated as a 4D-vector with its w-component being 1.0, so it
|
|
* will represent a position/location in 3D-space rather than a direction. This method is therefore
|
|
* not suited for perspective projection transformations as it will not save the
|
|
* <code>w</code> component of the transformed vector.
|
|
* For perspective projection use {@link #transform(double, double, double, double, Vector4d)} or
|
|
* {@link #transformProject(double, double, double, Vector3d)} when perspective divide should be applied, too.
|
|
*
|
|
* @see #transform(double, double, double, double, Vector4d)
|
|
* @see #transformProject(double, double, double, Vector3d)
|
|
*
|
|
* @param x
|
|
* the x coordinate of the position
|
|
* @param y
|
|
* the y coordinate of the position
|
|
* @param z
|
|
* the z coordinate of the position
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Vector3d transformPosition(double x, double y, double z, Vector3d dest);
|
|
|
|
/**
|
|
* Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by
|
|
* this matrix and store the result in that vector.
|
|
* <p>
|
|
* The given 3D-vector is treated as a 4D-vector with its w-component being <code>0.0</code>, so it
|
|
* will represent a direction in 3D-space rather than a position. This method will therefore
|
|
* not take the translation part of the matrix into account.
|
|
* <p>
|
|
* In order to store the result in another vector, use {@link #transformDirection(Vector3dc, Vector3d)}.
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @return v
|
|
*/
|
|
Vector3d transformDirection(Vector3d v);
|
|
|
|
/**
|
|
* Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by
|
|
* this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The given 3D-vector is treated as a 4D-vector with its w-component being <code>0.0</code>, so it
|
|
* will represent a direction in 3D-space rather than a position. This method will therefore
|
|
* not take the translation part of the matrix into account.
|
|
* <p>
|
|
* In order to store the result in the same vector, use {@link #transformDirection(Vector3d)}.
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Vector3d transformDirection(Vector3dc v, Vector3d dest);
|
|
|
|
/**
|
|
* Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by
|
|
* this matrix and store the result in that vector.
|
|
* <p>
|
|
* The given 3D-vector is treated as a 4D-vector with its w-component being <code>0.0</code>, so it
|
|
* will represent a direction in 3D-space rather than a position. This method will therefore
|
|
* not take the translation part of the matrix into account.
|
|
* <p>
|
|
* In order to store the result in another vector, use {@link #transformDirection(Vector3fc, Vector3f)}.
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @return v
|
|
*/
|
|
Vector3f transformDirection(Vector3f v);
|
|
|
|
/**
|
|
* Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by
|
|
* this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The given 3D-vector is treated as a 4D-vector with its w-component being <code>0.0</code>, so it
|
|
* will represent a direction in 3D-space rather than a position. This method will therefore
|
|
* not take the translation part of the matrix into account.
|
|
* <p>
|
|
* In order to store the result in the same vector, use {@link #transformDirection(Vector3f)}.
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Vector3f transformDirection(Vector3fc v, Vector3f dest);
|
|
|
|
/**
|
|
* Transform/multiply the 3D-vector <code>(x, y, z)</code>, as if it was a 4D-vector with w=0, by
|
|
* this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The given 3D-vector is treated as a 4D-vector with its w-component being <code>0.0</code>, so it
|
|
* will represent a direction in 3D-space rather than a position. This method will therefore
|
|
* not take the translation part of the matrix into account.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the direction to transform
|
|
* @param y
|
|
* the y coordinate of the direction to transform
|
|
* @param z
|
|
* the z coordinate of the direction to transform
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Vector3d transformDirection(double x, double y, double z, Vector3d dest);
|
|
|
|
/**
|
|
* Transform/multiply the 3D-vector <code>(x, y, z)</code>, as if it was a 4D-vector with w=0, by
|
|
* this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The given 3D-vector is treated as a 4D-vector with its w-component being <code>0.0</code>, so it
|
|
* will represent a direction in 3D-space rather than a position. This method will therefore
|
|
* not take the translation part of the matrix into account.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the direction to transform
|
|
* @param y
|
|
* the y coordinate of the direction to transform
|
|
* @param z
|
|
* the z coordinate of the direction to transform
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Vector3f transformDirection(double x, double y, double z, Vector3f dest);
|
|
|
|
/**
|
|
* Transform/multiply the given 4D-vector by assuming that <code>this</code> matrix represents an {@link #isAffine() affine} transformation
|
|
* (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>).
|
|
* <p>
|
|
* In order to store the result in another vector, use {@link #transformAffine(Vector4dc, Vector4d)}.
|
|
*
|
|
* @see #transformAffine(Vector4dc, Vector4d)
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @return v
|
|
*/
|
|
Vector4d transformAffine(Vector4d v);
|
|
|
|
/**
|
|
* Transform/multiply the given 4D-vector by assuming that <code>this</code> matrix represents an {@link #isAffine() affine} transformation
|
|
* (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>) and store the result in <code>dest</code>.
|
|
* <p>
|
|
* In order to store the result in the same vector, use {@link #transformAffine(Vector4d)}.
|
|
*
|
|
* @see #transformAffine(Vector4d)
|
|
*
|
|
* @param v
|
|
* the vector to transform and to hold the final result
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Vector4d transformAffine(Vector4dc v, Vector4d dest);
|
|
|
|
/**
|
|
* Transform/multiply the 4D-vector <code>(x, y, z, w)</code> by assuming that <code>this</code> matrix represents an {@link #isAffine() affine} transformation
|
|
* (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>) and store the result in <code>dest</code>.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the direction to transform
|
|
* @param y
|
|
* the y coordinate of the direction to transform
|
|
* @param z
|
|
* the z coordinate of the direction to transform
|
|
* @param w
|
|
* the w coordinate of the direction to transform
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Vector4d transformAffine(double x, double y, double z, double w, Vector4d dest);
|
|
|
|
/**
|
|
* Apply scaling to <code>this</code> matrix by scaling the base axes by the given <code>xyz.x</code>,
|
|
* <code>xyz.y</code> and <code>xyz.z</code> factors, respectively and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix,
|
|
* then the new matrix will be <code>M * S</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * S * v</code>
|
|
* , the scaling will be applied first!
|
|
*
|
|
* @param xyz
|
|
* the factors of the x, y and z component, respectively
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d scale(Vector3dc xyz, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply scaling to <code>this</code> matrix by scaling the base axes by the given x,
|
|
* y and z factors and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix,
|
|
* then the new matrix will be <code>M * S</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * S * v</code>
|
|
* , the scaling will be applied first!
|
|
*
|
|
* @param x
|
|
* the factor of the x component
|
|
* @param y
|
|
* the factor of the y component
|
|
* @param z
|
|
* the factor of the z component
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d scale(double x, double y, double z, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply scaling to this matrix by uniformly scaling all base axes by the given xyz factor
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix,
|
|
* then the new matrix will be <code>M * S</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * S * v</code>
|
|
* , the scaling will be applied first!
|
|
*
|
|
* @see #scale(double, double, double, Matrix4d)
|
|
*
|
|
* @param xyz
|
|
* the factor for all components
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d scale(double xyz, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply scaling to this matrix by by scaling the X axis by <code>x</code> and the Y axis by <code>y</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix,
|
|
* then the new matrix will be <code>M * S</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the
|
|
* scaling will be applied first!
|
|
*
|
|
* @param x
|
|
* the factor of the x component
|
|
* @param y
|
|
* the factor of the y component
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d scaleXY(double x, double y, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply scaling to <code>this</code> matrix by scaling the base axes by the given sx,
|
|
* sy and sz factors while using <code>(ox, oy, oz)</code> as the scaling origin,
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix,
|
|
* then the new matrix will be <code>M * S</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * S * v</code>
|
|
* , the scaling will be applied first!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>translate(ox, oy, oz, dest).scale(sx, sy, sz).translate(-ox, -oy, -oz)</code>
|
|
*
|
|
* @param sx
|
|
* the scaling factor of the x component
|
|
* @param sy
|
|
* the scaling factor of the y component
|
|
* @param sz
|
|
* the scaling factor of the z component
|
|
* @param ox
|
|
* the x coordinate of the scaling origin
|
|
* @param oy
|
|
* the y coordinate of the scaling origin
|
|
* @param oz
|
|
* the z coordinate of the scaling origin
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d scaleAround(double sx, double sy, double sz, double ox, double oy, double oz, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply scaling to this matrix by scaling all three base axes by the given <code>factor</code>
|
|
* while using <code>(ox, oy, oz)</code> as the scaling origin,
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix,
|
|
* then the new matrix will be <code>M * S</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the
|
|
* scaling will be applied first!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>translate(ox, oy, oz, dest).scale(factor).translate(-ox, -oy, -oz)</code>
|
|
*
|
|
* @param factor
|
|
* the scaling factor for all three axes
|
|
* @param ox
|
|
* the x coordinate of the scaling origin
|
|
* @param oy
|
|
* the y coordinate of the scaling origin
|
|
* @param oz
|
|
* the z coordinate of the scaling origin
|
|
* @param dest
|
|
* will hold the result
|
|
* @return this
|
|
*/
|
|
Matrix4d scaleAround(double factor, double ox, double oy, double oz, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply scaling to <code>this</code> matrix by scaling all base axes by the given <code>xyz</code> factor,
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix,
|
|
* then the new matrix will be <code>S * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>S * M * v</code>
|
|
* , the scaling will be applied last!
|
|
*
|
|
* @param xyz
|
|
* the factor to scale all three base axes by
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d scaleLocal(double xyz, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply scaling to <code>this</code> matrix by scaling the base axes by the given x,
|
|
* y and z factors and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix,
|
|
* then the new matrix will be <code>S * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>S * M * v</code>
|
|
* , the scaling will be applied last!
|
|
*
|
|
* @param x
|
|
* the factor of the x component
|
|
* @param y
|
|
* the factor of the y component
|
|
* @param z
|
|
* the factor of the z component
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d scaleLocal(double x, double y, double z, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply scaling to <code>this</code> matrix by scaling the base axes by the given sx,
|
|
* sy and sz factors while using the given <code>(ox, oy, oz)</code> as the scaling origin,
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix,
|
|
* then the new matrix will be <code>S * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>S * M * v</code>
|
|
* , the scaling will be applied last!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>new Matrix4d().translate(ox, oy, oz).scale(sx, sy, sz).translate(-ox, -oy, -oz).mul(this, dest)</code>
|
|
*
|
|
* @param sx
|
|
* the scaling factor of the x component
|
|
* @param sy
|
|
* the scaling factor of the y component
|
|
* @param sz
|
|
* the scaling factor of the z component
|
|
* @param ox
|
|
* the x coordinate of the scaling origin
|
|
* @param oy
|
|
* the y coordinate of the scaling origin
|
|
* @param oz
|
|
* the z coordinate of the scaling origin
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d scaleAroundLocal(double sx, double sy, double sz, double ox, double oy, double oz, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply scaling to this matrix by scaling all three base axes by the given <code>factor</code>
|
|
* while using <code>(ox, oy, oz)</code> as the scaling origin,
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix,
|
|
* then the new matrix will be <code>S * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>S * M * v</code>, the
|
|
* scaling will be applied last!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>new Matrix4d().translate(ox, oy, oz).scale(factor).translate(-ox, -oy, -oz).mul(this, dest)</code>
|
|
*
|
|
* @param factor
|
|
* the scaling factor for all three axes
|
|
* @param ox
|
|
* the x coordinate of the scaling origin
|
|
* @param oy
|
|
* the y coordinate of the scaling origin
|
|
* @param oz
|
|
* the z coordinate of the scaling origin
|
|
* @param dest
|
|
* will hold the result
|
|
* @return this
|
|
*/
|
|
Matrix4d scaleAroundLocal(double factor, double ox, double oy, double oz, Matrix4d 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 <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>
|
|
* , the rotation will be applied first!
|
|
*
|
|
* @param ang
|
|
* the angle is in radians
|
|
* @param x
|
|
* the x component of the axis
|
|
* @param y
|
|
* the y component of the axis
|
|
* @param z
|
|
* the z component of the axis
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotate(double ang, double x, double y, double z, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation to this matrix, which is assumed to only contain a translation, by rotating the given amount of radians
|
|
* about the specified <code>(x, y, z)</code> axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes <code>this</code> to only contain a translation.
|
|
* <p>
|
|
* The axis described by the three components needs to be a unit vector.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
|
|
*
|
|
* @param ang
|
|
* the angle in radians
|
|
* @param x
|
|
* the x component of the axis
|
|
* @param y
|
|
* the y component of the axis
|
|
* @param z
|
|
* the z component of the axis
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateTranslation(double ang, double x, double y, double z, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation to this {@link #isAffine() affine} matrix by rotating the given amount of radians
|
|
* about the specified <code>(x, y, z)</code> axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes <code>this</code> to be {@link #isAffine() affine}.
|
|
* <p>
|
|
* The axis described by the three components needs to be a unit vector.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
|
|
*
|
|
* @param ang
|
|
* the angle in radians
|
|
* @param x
|
|
* the x component of the axis
|
|
* @param y
|
|
* the y component of the axis
|
|
* @param z
|
|
* the z component of the axis
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateAffine(double ang, double x, double y, double z, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this {@link #isAffine() affine}
|
|
* matrix while using <code>(ox, oy, oz)</code> as the rotation origin, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>M * Q</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * Q * v</code>,
|
|
* the quaternion rotation will be applied first!
|
|
* <p>
|
|
* This method is only applicable if <code>this</code> is an {@link #isAffine() affine} matrix.
|
|
* <p>
|
|
* This method is equivalent to calling: <code>translate(ox, oy, oz, dest).rotate(quat).translate(-ox, -oy, -oz)</code>
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaterniondc}
|
|
* @param ox
|
|
* the x coordinate of the rotation origin
|
|
* @param oy
|
|
* the y coordinate of the rotation origin
|
|
* @param oz
|
|
* the z coordinate of the rotation origin
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateAroundAffine(Quaterniondc quat, double ox, double oy, double oz, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this matrix while using <code>(ox, oy, oz)</code> as the rotation origin,
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>M * Q</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * Q * v</code>,
|
|
* the quaternion rotation will be applied first!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>translate(ox, oy, oz, dest).rotate(quat).translate(-ox, -oy, -oz)</code>
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaterniondc}
|
|
* @param ox
|
|
* the x coordinate of the rotation origin
|
|
* @param oy
|
|
* the y coordinate of the rotation origin
|
|
* @param oz
|
|
* the z coordinate of the rotation origin
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateAround(Quaterniondc quat, double ox, double oy, double oz, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply a rotation to this matrix by rotating the given amount of radians
|
|
* about the specified <code>(x, y, z)</code> axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The axis described by the three components needs to be a unit vector.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>R * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the
|
|
* rotation will be applied last!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
|
|
*
|
|
* @param ang
|
|
* the angle in radians
|
|
* @param x
|
|
* the x component of the axis
|
|
* @param y
|
|
* the y component of the axis
|
|
* @param z
|
|
* the z component of the axis
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateLocal(double ang, double x, double y, double z, Matrix4d 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 <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>R * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the
|
|
* rotation will be applied last!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
|
|
*
|
|
* @param ang
|
|
* the angle in radians to rotate about the X axis
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateLocalX(double ang, Matrix4d 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 <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>R * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the
|
|
* rotation will be applied last!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
|
|
*
|
|
* @param ang
|
|
* the angle in radians to rotate about the Y axis
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateLocalY(double ang, Matrix4d 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 <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>R * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the
|
|
* rotation will be applied last!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>
|
|
*
|
|
* @param ang
|
|
* the angle in radians to rotate about the Z axis
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateLocalZ(double ang, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this matrix while using <code>(ox, oy, oz)</code>
|
|
* as the rotation origin, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>Q * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>Q * M * v</code>,
|
|
* the quaternion rotation will be applied last!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>translateLocal(-ox, -oy, -oz, dest).rotateLocal(quat).translateLocal(ox, oy, oz)</code>
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaterniondc}
|
|
* @param ox
|
|
* the x coordinate of the rotation origin
|
|
* @param oy
|
|
* the y coordinate of the rotation origin
|
|
* @param oz
|
|
* the z coordinate of the rotation origin
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateAroundLocal(Quaterniondc quat, double ox, double oy, double oz, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a translation to this matrix by translating by the given number of
|
|
* units in x, y and z and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation
|
|
* matrix, then the new matrix will be <code>M * T</code>. So when
|
|
* transforming a vector <code>v</code> with the new matrix by using
|
|
* <code>M * T * v</code>, the translation will be applied first!
|
|
*
|
|
* @param offset
|
|
* the number of units in x, y and z by which to translate
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d translate(Vector3dc offset, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a translation to this matrix by translating by the given number of
|
|
* units in x, y and z and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation
|
|
* matrix, then the new matrix will be <code>M * T</code>. So when
|
|
* transforming a vector <code>v</code> with the new matrix by using
|
|
* <code>M * T * v</code>, the translation will be applied first!
|
|
*
|
|
* @param offset
|
|
* the number of units in x, y and z by which to translate
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d translate(Vector3fc offset, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a translation to this matrix by translating by the given number of
|
|
* units in x, y and z and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation
|
|
* matrix, then the new matrix will be <code>M * T</code>. So when
|
|
* transforming a vector <code>v</code> with the new matrix by using
|
|
* <code>M * T * v</code>, the translation will be applied first!
|
|
*
|
|
* @param x
|
|
* the offset to translate in x
|
|
* @param y
|
|
* the offset to translate in y
|
|
* @param z
|
|
* the offset to translate in z
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d translate(double x, double y, double z, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply a translation to this matrix by translating by the given number of
|
|
* units in x, y and z and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation
|
|
* matrix, then the new matrix will be <code>T * M</code>. So when
|
|
* transforming a vector <code>v</code> with the new matrix by using
|
|
* <code>T * M * v</code>, the translation will be applied last!
|
|
*
|
|
* @param offset
|
|
* the number of units in x, y and z by which to translate
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d translateLocal(Vector3fc offset, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply a translation to this matrix by translating by the given number of
|
|
* units in x, y and z and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation
|
|
* matrix, then the new matrix will be <code>T * M</code>. So when
|
|
* transforming a vector <code>v</code> with the new matrix by using
|
|
* <code>T * M * v</code>, the translation will be applied last!
|
|
*
|
|
* @param offset
|
|
* the number of units in x, y and z by which to translate
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d translateLocal(Vector3dc offset, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply a translation to this matrix by translating by the given number of
|
|
* units in x, y and z and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation
|
|
* matrix, then the new matrix will be <code>T * M</code>. So when
|
|
* transforming a vector <code>v</code> with the new matrix by using
|
|
* <code>T * M * v</code>, the translation will be applied last!
|
|
*
|
|
* @param x
|
|
* the offset to translate in x
|
|
* @param y
|
|
* the offset to translate in y
|
|
* @param z
|
|
* the offset to translate in z
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d translateLocal(double x, double y, double z, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation about the X axis to this matrix by rotating the given amount of radians
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>
|
|
*
|
|
* @param ang
|
|
* the angle in radians
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateX(double ang, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation about the Y axis to this matrix by rotating the given amount of radians
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>
|
|
*
|
|
* @param ang
|
|
* the angle in radians
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateY(double ang, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation about the Z axis to this matrix by rotating the given amount of radians
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>
|
|
*
|
|
* @param ang
|
|
* the angle in radians
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateZ(double ang, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation about the Z axis to align the local <code>+X</code> towards <code>(dirX, dirY)</code> and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
* <p>
|
|
* The vector <code>(dirX, dirY)</code> must be a unit vector.
|
|
*
|
|
* @param dirX
|
|
* the x component of the normalized direction
|
|
* @param dirY
|
|
* the y component of the normalized direction
|
|
* @param dest
|
|
* will hold the result
|
|
* @return this
|
|
*/
|
|
Matrix4d rotateTowardsXY(double dirX, double dirY, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation of <code>angleX</code> radians about the X axis, followed by a rotation of <code>angleY</code> radians about the Y axis and
|
|
* followed by a rotation of <code>angleZ</code> radians about the Z axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>rotateX(angleX, dest).rotateY(angleY).rotateZ(angleZ)</code>
|
|
*
|
|
* @param angleX
|
|
* the angle to rotate about X
|
|
* @param angleY
|
|
* the angle to rotate about Y
|
|
* @param angleZ
|
|
* the angle to rotate about Z
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateXYZ(double angleX, double angleY, double angleZ, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation of <code>angleX</code> radians about the X axis, followed by a rotation of <code>angleY</code> radians about the Y axis and
|
|
* followed by a rotation of <code>angleZ</code> radians about the Z axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* This method assumes that <code>this</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>)
|
|
* and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination).
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
*
|
|
* @param angleX
|
|
* the angle to rotate about X
|
|
* @param angleY
|
|
* the angle to rotate about Y
|
|
* @param angleZ
|
|
* the angle to rotate about Z
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateAffineXYZ(double angleX, double angleY, double angleZ, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation of <code>angleZ</code> radians about the Z axis, followed by a rotation of <code>angleY</code> radians about the Y axis and
|
|
* followed by a rotation of <code>angleX</code> radians about the X axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>rotateZ(angleZ, dest).rotateY(angleY).rotateX(angleX)</code>
|
|
*
|
|
* @param angleZ
|
|
* the angle to rotate about Z
|
|
* @param angleY
|
|
* the angle to rotate about Y
|
|
* @param angleX
|
|
* the angle to rotate about X
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateZYX(double angleZ, double angleY, double angleX, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation of <code>angleZ</code> radians about the Z axis, followed by a rotation of <code>angleY</code> radians about the Y axis and
|
|
* followed by a rotation of <code>angleX</code> radians about the X axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* This method assumes that <code>this</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>)
|
|
* and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination).
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
*
|
|
* @param angleZ
|
|
* the angle to rotate about Z
|
|
* @param angleY
|
|
* the angle to rotate about Y
|
|
* @param angleX
|
|
* the angle to rotate about X
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateAffineZYX(double angleZ, double angleY, double angleX, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation of <code>angleY</code> radians about the Y axis, followed by a rotation of <code>angleX</code> radians about the X axis and
|
|
* followed by a rotation of <code>angleZ</code> radians about the Z axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>rotateY(angleY, dest).rotateX(angleX).rotateZ(angleZ)</code>
|
|
*
|
|
* @param angleY
|
|
* the angle to rotate about Y
|
|
* @param angleX
|
|
* the angle to rotate about X
|
|
* @param angleZ
|
|
* the angle to rotate about Z
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateYXZ(double angleY, double angleX, double angleZ, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply rotation of <code>angleY</code> radians about the Y axis, followed by a rotation of <code>angleX</code> radians about the X axis and
|
|
* followed by a rotation of <code>angleZ</code> radians about the Z axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* This method assumes that <code>this</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>)
|
|
* and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination).
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* rotation will be applied first!
|
|
*
|
|
* @param angleY
|
|
* the angle to rotate about Y
|
|
* @param angleX
|
|
* the angle to rotate about X
|
|
* @param angleZ
|
|
* the angle to rotate about Z
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateAffineYXZ(double angleY, double angleX, double angleZ, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this matrix and store
|
|
* the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>M * Q</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * Q * v</code>,
|
|
* the quaternion rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaterniondc}
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotate(Quaterniondc quat, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply the rotation - and possibly scaling - transformation of the given {@link Quaternionfc} to this matrix and store
|
|
* the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>M * Q</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * Q * v</code>,
|
|
* the quaternion rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaternionfc}
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotate(Quaternionfc quat, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this {@link #isAffine() affine} matrix and store
|
|
* the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes <code>this</code> to be {@link #isAffine() affine}.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>M * Q</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * Q * v</code>,
|
|
* the quaternion rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaterniondc}
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateAffine(Quaterniondc quat, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this matrix, which is assumed to only contain a translation, and store
|
|
* the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes <code>this</code> to only contain a translation.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>M * Q</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * Q * v</code>,
|
|
* the quaternion rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaterniondc}
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateTranslation(Quaterniondc quat, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply the rotation - and possibly scaling - transformation of the given {@link Quaternionfc} to this matrix, which is assumed to only contain a translation, and store
|
|
* the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes <code>this</code> to only contain a translation.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>M * Q</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * Q * v</code>,
|
|
* the quaternion rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaternionfc}
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateTranslation(Quaternionfc quat, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply the rotation - and possibly scaling - transformation of the given {@link Quaterniondc} to this matrix and store
|
|
* the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>Q * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>Q * M * v</code>,
|
|
* the quaternion rotation will be applied last!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaterniondc}
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateLocal(Quaterniondc quat, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply the rotation - and possibly scaling - transformation of the given {@link Quaternionfc} to this {@link #isAffine() affine} matrix and store
|
|
* the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes <code>this</code> to be {@link #isAffine() affine}.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>M * Q</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * Q * v</code>,
|
|
* the quaternion rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaternionfc}
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateAffine(Quaternionfc quat, Matrix4d dest);
|
|
|
|
/**
|
|
* Pre-multiply the rotation - and possibly scaling - transformation of the given {@link Quaternionfc} to this matrix and store
|
|
* the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion,
|
|
* then the new matrix will be <code>Q * M</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>Q * M * v</code>,
|
|
* the quaternion rotation will be applied last!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>
|
|
*
|
|
* @param quat
|
|
* the {@link Quaternionfc}
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateLocal(Quaternionfc quat, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a rotation transformation, rotating about the given {@link AxisAngle4f} and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The axis described by the <code>axis</code> vector needs to be a unit vector.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given {@link AxisAngle4f},
|
|
* then the new matrix will be <code>M * A</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * A * v</code>,
|
|
* the {@link AxisAngle4f} rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
|
|
*
|
|
* @see #rotate(double, double, double, double, Matrix4d)
|
|
*
|
|
* @param axisAngle
|
|
* the {@link AxisAngle4f} (needs to be {@link AxisAngle4f#normalize() normalized})
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotate(AxisAngle4f axisAngle, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a rotation transformation, rotating about the given {@link AxisAngle4d} and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given {@link AxisAngle4d},
|
|
* then the new matrix will be <code>M * A</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * A * v</code>,
|
|
* the {@link AxisAngle4d} rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
|
|
*
|
|
* @see #rotate(double, double, double, double, Matrix4d)
|
|
*
|
|
* @param axisAngle
|
|
* the {@link AxisAngle4d} (needs to be {@link AxisAngle4d#normalize() normalized})
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotate(AxisAngle4d axisAngle, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a rotation transformation, rotating the given radians about the specified axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given angle and axis,
|
|
* then the new matrix will be <code>M * A</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * A * v</code>,
|
|
* the axis-angle rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
|
|
*
|
|
* @see #rotate(double, double, double, double, Matrix4d)
|
|
*
|
|
* @param angle
|
|
* the angle in radians
|
|
* @param axis
|
|
* the rotation axis (needs to be {@link Vector3d#normalize() normalized})
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotate(double angle, Vector3dc axis, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a rotation transformation, rotating the given radians about the specified axis and store the result in <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given angle and axis,
|
|
* then the new matrix will be <code>M * A</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * A * v</code>,
|
|
* the axis-angle rotation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>
|
|
*
|
|
* @see #rotate(double, double, double, double, Matrix4d)
|
|
*
|
|
* @param angle
|
|
* the angle in radians
|
|
* @param axis
|
|
* the rotation axis (needs to be {@link Vector3f#normalize() normalized})
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotate(double angle, Vector3fc axis, Matrix4d dest);
|
|
|
|
/**
|
|
* Get the row at the given <code>row</code> index, starting with <code>0</code>.
|
|
*
|
|
* @param row
|
|
* the row index in <code>[0..3]</code>
|
|
* @param dest
|
|
* will hold the row components
|
|
* @return the passed in destination
|
|
* @throws IndexOutOfBoundsException if <code>row</code> is not in <code>[0..3]</code>
|
|
*/
|
|
Vector4d getRow(int row, Vector4d dest) throws IndexOutOfBoundsException;
|
|
|
|
/**
|
|
* Get the first three components of the row at the given <code>row</code> index, starting with <code>0</code>.
|
|
*
|
|
* @param row
|
|
* the row index in <code>[0..3]</code>
|
|
* @param dest
|
|
* will hold the first three row components
|
|
* @return the passed in destination
|
|
* @throws IndexOutOfBoundsException if <code>row</code> is not in <code>[0..3]</code>
|
|
*/
|
|
Vector3d getRow(int row, Vector3d dest) throws IndexOutOfBoundsException;
|
|
|
|
/**
|
|
* Get the column at the given <code>column</code> index, starting with <code>0</code>.
|
|
*
|
|
* @param column
|
|
* the column index in <code>[0..3]</code>
|
|
* @param dest
|
|
* will hold the column components
|
|
* @return the passed in destination
|
|
* @throws IndexOutOfBoundsException if <code>column</code> is not in <code>[0..3]</code>
|
|
*/
|
|
Vector4d getColumn(int column, Vector4d dest) throws IndexOutOfBoundsException;
|
|
|
|
/**
|
|
* Get the first three components of the column at the given <code>column</code> index, starting with <code>0</code>.
|
|
*
|
|
* @param column
|
|
* the column index in <code>[0..3]</code>
|
|
* @param dest
|
|
* will hold the first three column components
|
|
* @return the passed in destination
|
|
* @throws IndexOutOfBoundsException if <code>column</code> is not in <code>[0..3]</code>
|
|
*/
|
|
Vector3d getColumn(int column, Vector3d dest) throws IndexOutOfBoundsException;
|
|
|
|
/**
|
|
* Get the matrix element value at the given column and row.
|
|
*
|
|
* @param column
|
|
* the colum index in <code>[0..3]</code>
|
|
* @param row
|
|
* the row index in <code>[0..3]</code>
|
|
* @return the element value
|
|
*/
|
|
double get(int column, int row);
|
|
|
|
/**
|
|
* Get the matrix element value at the given row and column.
|
|
*
|
|
* @param row
|
|
* the row index in <code>[0..3]</code>
|
|
* @param column
|
|
* the colum index in <code>[0..3]</code>
|
|
* @return the element value
|
|
*/
|
|
double getRowColumn(int row, int column);
|
|
|
|
/**
|
|
* Compute a normal matrix from the upper left 3x3 submatrix of <code>this</code>
|
|
* and store it into the upper left 3x3 submatrix of <code>dest</code>.
|
|
* All other values of <code>dest</code> will be set to identity.
|
|
* <p>
|
|
* The normal matrix of <code>m</code> is the transpose of the inverse of <code>m</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d normal(Matrix4d dest);
|
|
|
|
/**
|
|
* Compute a normal matrix from the upper left 3x3 submatrix of <code>this</code>
|
|
* and store it into <code>dest</code>.
|
|
* <p>
|
|
* The normal matrix of <code>m</code> is the transpose of the inverse of <code>m</code>.
|
|
*
|
|
* @see #get3x3(Matrix3d)
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix3d normal(Matrix3d dest);
|
|
|
|
/**
|
|
* Compute the cofactor matrix of the upper left 3x3 submatrix of <code>this</code>
|
|
* and store it into <code>dest</code>.
|
|
* <p>
|
|
* 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.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix3d cofactor3x3(Matrix3d dest);
|
|
|
|
/**
|
|
* Compute the cofactor matrix of the upper left 3x3 submatrix of <code>this</code>
|
|
* and store it into <code>dest</code>.
|
|
* All other values of <code>dest</code> will be set to identity.
|
|
* <p>
|
|
* 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.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d cofactor3x3(Matrix4d dest);
|
|
|
|
/**
|
|
* Normalize the upper left 3x3 submatrix of this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The resulting matrix will map unit vectors to unit vectors, though a pair of orthogonal input unit
|
|
* vectors need not be mapped to a pair of orthogonal output vectors if the original matrix was not orthogonal itself
|
|
* (i.e. had <i>skewing</i>).
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d normalize3x3(Matrix4d dest);
|
|
|
|
/**
|
|
* Normalize the upper left 3x3 submatrix of this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The resulting matrix will map unit vectors to unit vectors, though a pair of orthogonal input unit
|
|
* vectors need not be mapped to a pair of orthogonal output vectors if the original matrix was not orthogonal itself
|
|
* (i.e. had <i>skewing</i>).
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix3d normalize3x3(Matrix3d dest);
|
|
|
|
/**
|
|
* Unproject the given window coordinates <code>(winX, winY, winZ)</code> by <code>this</code> matrix using the specified viewport.
|
|
* <p>
|
|
* This method first converts the given window coordinates to normalized device coordinates in the range <code>[-1..1]</code>
|
|
* and then transforms those NDC coordinates by the inverse of <code>this</code> matrix.
|
|
* <p>
|
|
* The depth range of <code>winZ</code> is assumed to be <code>[0..1]</code>, which is also the OpenGL default.
|
|
* <p>
|
|
* As a necessary computation step for unprojecting, this method computes the inverse of <code>this</code> matrix.
|
|
* In order to avoid computing the matrix inverse with every invocation, the inverse of <code>this</code> matrix can be built
|
|
* once outside using {@link #invert(Matrix4d)} and then the method {@link #unprojectInv(double, double, double, int[], Vector4d) unprojectInv()} can be invoked on it.
|
|
*
|
|
* @see #unprojectInv(double, double, double, int[], Vector4d)
|
|
* @see #invert(Matrix4d)
|
|
*
|
|
* @param winX
|
|
* the x-coordinate in window coordinates (pixels)
|
|
* @param winY
|
|
* the y-coordinate in window coordinates (pixels)
|
|
* @param winZ
|
|
* the z-coordinate, which is the depth value in <code>[0..1]</code>
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param dest
|
|
* will hold the unprojected position
|
|
* @return dest
|
|
*/
|
|
Vector4d unproject(double winX, double winY, double winZ, int[] viewport, Vector4d dest);
|
|
|
|
/**
|
|
* Unproject the given window coordinates <code>(winX, winY, winZ)</code> by <code>this</code> matrix using the specified viewport.
|
|
* <p>
|
|
* This method first converts the given window coordinates to normalized device coordinates in the range <code>[-1..1]</code>
|
|
* and then transforms those NDC coordinates by the inverse of <code>this</code> matrix.
|
|
* <p>
|
|
* The depth range of <code>winZ</code> is assumed to be <code>[0..1]</code>, which is also the OpenGL default.
|
|
* <p>
|
|
* As a necessary computation step for unprojecting, this method computes the inverse of <code>this</code> matrix.
|
|
* In order to avoid computing the matrix inverse with every invocation, the inverse of <code>this</code> matrix can be built
|
|
* once outside using {@link #invert(Matrix4d)} and then the method {@link #unprojectInv(double, double, double, int[], Vector3d) unprojectInv()} can be invoked on it.
|
|
*
|
|
* @see #unprojectInv(double, double, double, int[], Vector3d)
|
|
* @see #invert(Matrix4d)
|
|
*
|
|
* @param winX
|
|
* the x-coordinate in window coordinates (pixels)
|
|
* @param winY
|
|
* the y-coordinate in window coordinates (pixels)
|
|
* @param winZ
|
|
* the z-coordinate, which is the depth value in <code>[0..1]</code>
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param dest
|
|
* will hold the unprojected position
|
|
* @return dest
|
|
*/
|
|
Vector3d unproject(double winX, double winY, double winZ, int[] viewport, Vector3d dest);
|
|
|
|
/**
|
|
* Unproject the given window coordinates <code>winCoords</code> by <code>this</code> matrix using the specified viewport.
|
|
* <p>
|
|
* This method first converts the given window coordinates to normalized device coordinates in the range <code>[-1..1]</code>
|
|
* and then transforms those NDC coordinates by the inverse of <code>this</code> matrix.
|
|
* <p>
|
|
* The depth range of <code>winCoords.z</code> is assumed to be <code>[0..1]</code>, which is also the OpenGL default.
|
|
* <p>
|
|
* As a necessary computation step for unprojecting, this method computes the inverse of <code>this</code> matrix.
|
|
* In order to avoid computing the matrix inverse with every invocation, the inverse of <code>this</code> matrix can be built
|
|
* once outside using {@link #invert(Matrix4d)} and then the method {@link #unprojectInv(double, double, double, int[], Vector4d) unprojectInv()} can be invoked on it.
|
|
*
|
|
* @see #unprojectInv(double, double, double, int[], Vector4d)
|
|
* @see #unproject(double, double, double, int[], Vector4d)
|
|
* @see #invert(Matrix4d)
|
|
*
|
|
* @param winCoords
|
|
* the window coordinates to unproject
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param dest
|
|
* will hold the unprojected position
|
|
* @return dest
|
|
*/
|
|
Vector4d unproject(Vector3dc winCoords, int[] viewport, Vector4d dest);
|
|
|
|
/**
|
|
* Unproject the given window coordinates <code>winCoords</code> by <code>this</code> matrix using the specified viewport.
|
|
* <p>
|
|
* This method first converts the given window coordinates to normalized device coordinates in the range <code>[-1..1]</code>
|
|
* and then transforms those NDC coordinates by the inverse of <code>this</code> matrix.
|
|
* <p>
|
|
* The depth range of <code>winCoords.z</code> is assumed to be <code>[0..1]</code>, which is also the OpenGL default.
|
|
* <p>
|
|
* As a necessary computation step for unprojecting, this method computes the inverse of <code>this</code> matrix.
|
|
* In order to avoid computing the matrix inverse with every invocation, the inverse of <code>this</code> matrix can be built
|
|
* once outside using {@link #invert(Matrix4d)} and then the method {@link #unprojectInv(double, double, double, int[], Vector4d) unprojectInv()} can be invoked on it.
|
|
*
|
|
* @see #unprojectInv(double, double, double, int[], Vector4d)
|
|
* @see #unproject(double, double, double, int[], Vector4d)
|
|
* @see #invert(Matrix4d)
|
|
*
|
|
* @param winCoords
|
|
* the window coordinates to unproject
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param dest
|
|
* will hold the unprojected position
|
|
* @return dest
|
|
*/
|
|
Vector3d unproject(Vector3dc winCoords, int[] viewport, Vector3d dest);
|
|
|
|
/**
|
|
* Unproject the given 2D window coordinates <code>(winX, winY)</code> by <code>this</code> matrix using the specified viewport
|
|
* and compute the origin and the direction of the resulting ray which starts at NDC <code>z = -1.0</code> and goes through NDC <code>z = +1.0</code>.
|
|
* <p>
|
|
* This method first converts the given window coordinates to normalized device coordinates in the range <code>[-1..1]</code>
|
|
* and then transforms those NDC coordinates by the inverse of <code>this</code> matrix.
|
|
* <p>
|
|
* As a necessary computation step for unprojecting, this method computes the inverse of <code>this</code> matrix.
|
|
* In order to avoid computing the matrix inverse with every invocation, the inverse of <code>this</code> matrix can be built
|
|
* once outside using {@link #invert(Matrix4d)} and then the method {@link #unprojectInvRay(double, double, int[], Vector3d, Vector3d) unprojectInvRay()} can be invoked on it.
|
|
*
|
|
* @see #unprojectInvRay(double, double, int[], Vector3d, Vector3d)
|
|
* @see #invert(Matrix4d)
|
|
*
|
|
* @param winX
|
|
* the x-coordinate in window coordinates (pixels)
|
|
* @param winY
|
|
* the y-coordinate in window coordinates (pixels)
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param originDest
|
|
* will hold the ray origin
|
|
* @param dirDest
|
|
* will hold the (unnormalized) ray direction
|
|
* @return this
|
|
*/
|
|
Matrix4d unprojectRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest);
|
|
|
|
/**
|
|
* Unproject the given 2D window coordinates <code>winCoords</code> by <code>this</code> matrix using the specified viewport
|
|
* and compute the origin and the direction of the resulting ray which starts at NDC <code>z = -1.0</code> and goes through NDC <code>z = +1.0</code>.
|
|
* <p>
|
|
* This method first converts the given window coordinates to normalized device coordinates in the range <code>[-1..1]</code>
|
|
* and then transforms those NDC coordinates by the inverse of <code>this</code> matrix.
|
|
* <p>
|
|
* As a necessary computation step for unprojecting, this method computes the inverse of <code>this</code> matrix.
|
|
* In order to avoid computing the matrix inverse with every invocation, the inverse of <code>this</code> matrix can be built
|
|
* once outside using {@link #invert(Matrix4d)} and then the method {@link #unprojectInvRay(double, double, int[], Vector3d, Vector3d) unprojectInvRay()} can be invoked on it.
|
|
*
|
|
* @see #unprojectInvRay(double, double, int[], Vector3d, Vector3d)
|
|
* @see #unprojectRay(double, double, int[], Vector3d, Vector3d)
|
|
* @see #invert(Matrix4d)
|
|
*
|
|
* @param winCoords
|
|
* the window coordinates to unproject
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param originDest
|
|
* will hold the ray origin
|
|
* @param dirDest
|
|
* will hold the (unnormalized) ray direction
|
|
* @return this
|
|
*/
|
|
Matrix4d unprojectRay(Vector2dc winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest);
|
|
|
|
/**
|
|
* Unproject the given window coordinates <code>winCoords</code> by <code>this</code> matrix using the specified viewport.
|
|
* <p>
|
|
* This method differs from {@link #unproject(Vector3dc, int[], Vector4d) unproject()}
|
|
* in that it assumes that <code>this</code> is already the inverse matrix of the original projection matrix.
|
|
* It exists to avoid recomputing the matrix inverse with every invocation.
|
|
* <p>
|
|
* This method first converts the given window coordinates to normalized device coordinates in the range <code>[-1..1]</code>
|
|
* and then transforms those NDC coordinates by <code>this</code> matrix.
|
|
* <p>
|
|
* The depth range of <code>winCoords.z</code> is assumed to be <code>[0..1]</code>, which is also the OpenGL default.
|
|
*
|
|
* @see #unproject(Vector3dc, int[], Vector4d)
|
|
*
|
|
* @param winCoords
|
|
* the window coordinates to unproject
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param dest
|
|
* will hold the unprojected position
|
|
* @return dest
|
|
*/
|
|
Vector4d unprojectInv(Vector3dc winCoords, int[] viewport, Vector4d dest);
|
|
|
|
/**
|
|
* Unproject the given window coordinates <code>(winX, winY, winZ)</code> by <code>this</code> matrix using the specified viewport.
|
|
* <p>
|
|
* This method differs from {@link #unproject(double, double, double, int[], Vector4d) unproject()}
|
|
* in that it assumes that <code>this</code> is already the inverse matrix of the original projection matrix.
|
|
* It exists to avoid recomputing the matrix inverse with every invocation.
|
|
* <p>
|
|
* This method first converts the given window coordinates to normalized device coordinates in the range <code>[-1..1]</code>
|
|
* and then transforms those NDC coordinates by <code>this</code> matrix.
|
|
* <p>
|
|
* The depth range of <code>winZ</code> is assumed to be <code>[0..1]</code>, which is also the OpenGL default.
|
|
*
|
|
* @see #unproject(double, double, double, int[], Vector4d)
|
|
*
|
|
* @param winX
|
|
* the x-coordinate in window coordinates (pixels)
|
|
* @param winY
|
|
* the y-coordinate in window coordinates (pixels)
|
|
* @param winZ
|
|
* the z-coordinate, which is the depth value in <code>[0..1]</code>
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param dest
|
|
* will hold the unprojected position
|
|
* @return dest
|
|
*/
|
|
Vector4d unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector4d dest);
|
|
|
|
/**
|
|
* Unproject the given window coordinates <code>winCoords</code> by <code>this</code> matrix using the specified viewport.
|
|
* <p>
|
|
* This method differs from {@link #unproject(Vector3dc, int[], Vector3d) unproject()}
|
|
* in that it assumes that <code>this</code> is already the inverse matrix of the original projection matrix.
|
|
* It exists to avoid recomputing the matrix inverse with every invocation.
|
|
* <p>
|
|
* This method first converts the given window coordinates to normalized device coordinates in the range <code>[-1..1]</code>
|
|
* and then transforms those NDC coordinates by <code>this</code> matrix.
|
|
* <p>
|
|
* The depth range of <code>winCoords.z</code> is assumed to be <code>[0..1]</code>, which is also the OpenGL default.
|
|
*
|
|
* @see #unproject(Vector3dc, int[], Vector3d)
|
|
*
|
|
* @param winCoords
|
|
* the window coordinates to unproject
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param dest
|
|
* will hold the unprojected position
|
|
* @return dest
|
|
*/
|
|
Vector3d unprojectInv(Vector3dc winCoords, int[] viewport, Vector3d dest);
|
|
|
|
/**
|
|
* Unproject the given window coordinates <code>(winX, winY, winZ)</code> by <code>this</code> matrix using the specified viewport.
|
|
* <p>
|
|
* This method differs from {@link #unproject(double, double, double, int[], Vector3d) unproject()}
|
|
* in that it assumes that <code>this</code> is already the inverse matrix of the original projection matrix.
|
|
* It exists to avoid recomputing the matrix inverse with every invocation.
|
|
* <p>
|
|
* This method first converts the given window coordinates to normalized device coordinates in the range <code>[-1..1]</code>
|
|
* and then transforms those NDC coordinates by <code>this</code> matrix.
|
|
* <p>
|
|
* The depth range of <code>winZ</code> is assumed to be <code>[0..1]</code>, which is also the OpenGL default.
|
|
*
|
|
* @see #unproject(double, double, double, int[], Vector3d)
|
|
*
|
|
* @param winX
|
|
* the x-coordinate in window coordinates (pixels)
|
|
* @param winY
|
|
* the y-coordinate in window coordinates (pixels)
|
|
* @param winZ
|
|
* the z-coordinate, which is the depth value in <code>[0..1]</code>
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param dest
|
|
* will hold the unprojected position
|
|
* @return dest
|
|
*/
|
|
Vector3d unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector3d dest);
|
|
|
|
/**
|
|
* Unproject the given window coordinates <code>winCoords</code> by <code>this</code> matrix using the specified viewport
|
|
* and compute the origin and the direction of the resulting ray which starts at NDC <code>z = -1.0</code> and goes through NDC <code>z = +1.0</code>.
|
|
* <p>
|
|
* This method differs from {@link #unprojectRay(Vector2dc, int[], Vector3d, Vector3d) unprojectRay()}
|
|
* in that it assumes that <code>this</code> is already the inverse matrix of the original projection matrix.
|
|
* It exists to avoid recomputing the matrix inverse with every invocation.
|
|
*
|
|
* @see #unprojectRay(Vector2dc, int[], Vector3d, Vector3d)
|
|
*
|
|
* @param winCoords
|
|
* the window coordinates to unproject
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param originDest
|
|
* will hold the ray origin
|
|
* @param dirDest
|
|
* will hold the (unnormalized) ray direction
|
|
* @return this
|
|
*/
|
|
Matrix4d unprojectInvRay(Vector2dc winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest);
|
|
|
|
/**
|
|
* Unproject the given 2D window coordinates <code>(winX, winY)</code> by <code>this</code> matrix using the specified viewport
|
|
* and compute the origin and the direction of the resulting ray which starts at NDC <code>z = -1.0</code> and goes through NDC <code>z = +1.0</code>.
|
|
* <p>
|
|
* This method differs from {@link #unprojectRay(double, double, int[], Vector3d, Vector3d) unprojectRay()}
|
|
* in that it assumes that <code>this</code> is already the inverse matrix of the original projection matrix.
|
|
* It exists to avoid recomputing the matrix inverse with every invocation.
|
|
*
|
|
* @see #unprojectRay(double, double, int[], Vector3d, Vector3d)
|
|
*
|
|
* @param winX
|
|
* the x-coordinate in window coordinates (pixels)
|
|
* @param winY
|
|
* the y-coordinate in window coordinates (pixels)
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param originDest
|
|
* will hold the ray origin
|
|
* @param dirDest
|
|
* will hold the (unnormalized) ray direction
|
|
* @return this
|
|
*/
|
|
Matrix4d unprojectInvRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest);
|
|
|
|
/**
|
|
* Project the given <code>(x, y, z)</code> position via <code>this</code> matrix using the specified viewport
|
|
* and store the resulting window coordinates in <code>winCoordsDest</code>.
|
|
* <p>
|
|
* This method transforms the given coordinates by <code>this</code> matrix including perspective division to
|
|
* obtain normalized device coordinates, and then translates these into window coordinates by using the
|
|
* given <code>viewport</code> settings <code>[x, y, width, height]</code>.
|
|
* <p>
|
|
* The depth range of the returned <code>winCoordsDest.z</code> will be <code>[0..1]</code>, which is also the OpenGL default.
|
|
*
|
|
* @param x
|
|
* the x-coordinate of the position to project
|
|
* @param y
|
|
* the y-coordinate of the position to project
|
|
* @param z
|
|
* the z-coordinate of the position to project
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param winCoordsDest
|
|
* will hold the projected window coordinates
|
|
* @return winCoordsDest
|
|
*/
|
|
Vector4d project(double x, double y, double z, int[] viewport, Vector4d winCoordsDest);
|
|
|
|
/**
|
|
* Project the given <code>(x, y, z)</code> position via <code>this</code> matrix using the specified viewport
|
|
* and store the resulting window coordinates in <code>winCoordsDest</code>.
|
|
* <p>
|
|
* This method transforms the given coordinates by <code>this</code> matrix including perspective division to
|
|
* obtain normalized device coordinates, and then translates these into window coordinates by using the
|
|
* given <code>viewport</code> settings <code>[x, y, width, height]</code>.
|
|
* <p>
|
|
* The depth range of the returned <code>winCoordsDest.z</code> will be <code>[0..1]</code>, which is also the OpenGL default.
|
|
*
|
|
* @param x
|
|
* the x-coordinate of the position to project
|
|
* @param y
|
|
* the y-coordinate of the position to project
|
|
* @param z
|
|
* the z-coordinate of the position to project
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param winCoordsDest
|
|
* will hold the projected window coordinates
|
|
* @return winCoordsDest
|
|
*/
|
|
Vector3d project(double x, double y, double z, int[] viewport, Vector3d winCoordsDest);
|
|
|
|
/**
|
|
* Project the given <code>position</code> via <code>this</code> matrix using the specified viewport
|
|
* and store the resulting window coordinates in <code>winCoordsDest</code>.
|
|
* <p>
|
|
* This method transforms the given coordinates by <code>this</code> matrix including perspective division to
|
|
* obtain normalized device coordinates, and then translates these into window coordinates by using the
|
|
* given <code>viewport</code> settings <code>[x, y, width, height]</code>.
|
|
* <p>
|
|
* The depth range of the returned <code>winCoordsDest.z</code> will be <code>[0..1]</code>, which is also the OpenGL default.
|
|
*
|
|
* @see #project(double, double, double, int[], Vector4d)
|
|
*
|
|
* @param position
|
|
* the position to project into window coordinates
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param winCoordsDest
|
|
* will hold the projected window coordinates
|
|
* @return winCoordsDest
|
|
*/
|
|
Vector4d project(Vector3dc position, int[] viewport, Vector4d winCoordsDest);
|
|
|
|
/**
|
|
* Project the given <code>position</code> via <code>this</code> matrix using the specified viewport
|
|
* and store the resulting window coordinates in <code>winCoordsDest</code>.
|
|
* <p>
|
|
* This method transforms the given coordinates by <code>this</code> matrix including perspective division to
|
|
* obtain normalized device coordinates, and then translates these into window coordinates by using the
|
|
* given <code>viewport</code> settings <code>[x, y, width, height]</code>.
|
|
* <p>
|
|
* The depth range of the returned <code>winCoordsDest.z</code> will be <code>[0..1]</code>, which is also the OpenGL default.
|
|
*
|
|
* @see #project(double, double, double, int[], Vector4d)
|
|
*
|
|
* @param position
|
|
* the position to project into window coordinates
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param winCoordsDest
|
|
* will hold the projected window coordinates
|
|
* @return winCoordsDest
|
|
*/
|
|
Vector3d project(Vector3dc position, int[] viewport, Vector3d winCoordsDest);
|
|
|
|
/**
|
|
* Apply a mirror/reflection transformation to this matrix that reflects about the given plane
|
|
* specified via the equation <code>x*a + y*b + z*c + d = 0</code> and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The vector <code>(a, b, c)</code> must be a unit vector.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* reflection will be applied first!
|
|
* <p>
|
|
* Reference: <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/bb281733(v=vs.85).aspx">msdn.microsoft.com</a>
|
|
*
|
|
* @param a
|
|
* the x factor in the plane equation
|
|
* @param b
|
|
* the y factor in the plane equation
|
|
* @param c
|
|
* the z factor in the plane equation
|
|
* @param d
|
|
* the constant in the plane equation
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d reflect(double a, double b, double c, double d, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a mirror/reflection transformation to this matrix that reflects about the given plane
|
|
* specified via the plane normal and a point on the plane, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* reflection will be applied first!
|
|
*
|
|
* @param nx
|
|
* the x-coordinate of the plane normal
|
|
* @param ny
|
|
* the y-coordinate of the plane normal
|
|
* @param nz
|
|
* the z-coordinate of the plane normal
|
|
* @param px
|
|
* the x-coordinate of a point on the plane
|
|
* @param py
|
|
* the y-coordinate of a point on the plane
|
|
* @param pz
|
|
* the z-coordinate of a point on the plane
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d reflect(double nx, double ny, double nz, double px, double py, double pz, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a mirror/reflection transformation to this matrix that reflects about a plane
|
|
* specified via the plane orientation and a point on the plane, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method can be used to build a reflection transformation based on the orientation of a mirror object in the scene.
|
|
* It is assumed that the default mirror plane's normal is <code>(0, 0, 1)</code>. So, if the given {@link Quaterniondc} is
|
|
* the identity (does not apply any additional rotation), the reflection plane will be <code>z=0</code>, offset by the given <code>point</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* reflection will be applied first!
|
|
*
|
|
* @param orientation
|
|
* the plane orientation
|
|
* @param point
|
|
* a point on the plane
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d reflect(Quaterniondc orientation, Vector3dc point, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a mirror/reflection transformation to this matrix that reflects about the given plane
|
|
* specified via the plane normal and a point on the plane, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix,
|
|
* then the new matrix will be <code>M * R</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the
|
|
* reflection will be applied first!
|
|
*
|
|
* @param normal
|
|
* the plane normal
|
|
* @param point
|
|
* a point on the plane
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d reflect(Vector3dc normal, Vector3dc point, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an orthographic projection transformation for a right-handed coordinate system
|
|
* using the given NDC z range to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* orthographic projection transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
|
|
*
|
|
* @param left
|
|
* the distance from the center to the left frustum edge
|
|
* @param right
|
|
* the distance from the center to the right frustum edge
|
|
* @param bottom
|
|
* the distance from the center to the bottom frustum edge
|
|
* @param top
|
|
* the distance from the center to the top frustum edge
|
|
* @param zNear
|
|
* near clipping plane distance
|
|
* @param zFar
|
|
* far clipping plane distance
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d ortho(double left, double right, double bottom, double top, double zNear, double zFar, boolean zZeroToOne, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an orthographic projection transformation for a right-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* orthographic projection transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
|
|
*
|
|
* @param left
|
|
* the distance from the center to the left frustum edge
|
|
* @param right
|
|
* the distance from the center to the right frustum edge
|
|
* @param bottom
|
|
* the distance from the center to the bottom frustum edge
|
|
* @param top
|
|
* the distance from the center to the top frustum edge
|
|
* @param zNear
|
|
* near clipping plane distance
|
|
* @param zFar
|
|
* far clipping plane distance
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d ortho(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an orthographic projection transformation for a left-handed coordiante system
|
|
* using the given NDC z range to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* orthographic projection transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
|
|
*
|
|
* @param left
|
|
* the distance from the center to the left frustum edge
|
|
* @param right
|
|
* the distance from the center to the right frustum edge
|
|
* @param bottom
|
|
* the distance from the center to the bottom frustum edge
|
|
* @param top
|
|
* the distance from the center to the top frustum edge
|
|
* @param zNear
|
|
* near clipping plane distance
|
|
* @param zFar
|
|
* far clipping plane distance
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, boolean zZeroToOne, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an orthographic projection transformation for a left-handed coordiante system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* orthographic projection transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
|
|
*
|
|
* @param left
|
|
* the distance from the center to the left frustum edge
|
|
* @param right
|
|
* the distance from the center to the right frustum edge
|
|
* @param bottom
|
|
* the distance from the center to the bottom frustum edge
|
|
* @param top
|
|
* the distance from the center to the top frustum edge
|
|
* @param zNear
|
|
* near clipping plane distance
|
|
* @param zFar
|
|
* far clipping plane distance
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a symmetric orthographic projection transformation for a right-handed coordinate system
|
|
* using the given NDC z range to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, boolean, Matrix4d) ortho()} with
|
|
* <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* orthographic projection transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
|
|
*
|
|
* @param width
|
|
* the distance between the right and left frustum edges
|
|
* @param height
|
|
* the distance between the top and bottom frustum edges
|
|
* @param zNear
|
|
* near clipping plane distance
|
|
* @param zFar
|
|
* far clipping plane distance
|
|
* @param dest
|
|
* will hold the result
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @return dest
|
|
*/
|
|
Matrix4d orthoSymmetric(double width, double height, double zNear, double zFar, boolean zZeroToOne, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a symmetric orthographic projection transformation for a right-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, Matrix4d) ortho()} with
|
|
* <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* orthographic projection transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
|
|
*
|
|
* @param width
|
|
* the distance between the right and left frustum edges
|
|
* @param height
|
|
* the distance between the top and bottom frustum edges
|
|
* @param zNear
|
|
* near clipping plane distance
|
|
* @param zFar
|
|
* far clipping plane distance
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d orthoSymmetric(double width, double height, double zNear, double zFar, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a symmetric orthographic projection transformation for a left-handed coordinate system
|
|
* using the given NDC z range to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, boolean, Matrix4d) orthoLH()} with
|
|
* <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* orthographic projection transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
|
|
*
|
|
* @param width
|
|
* the distance between the right and left frustum edges
|
|
* @param height
|
|
* the distance between the top and bottom frustum edges
|
|
* @param zNear
|
|
* near clipping plane distance
|
|
* @param zFar
|
|
* far clipping plane distance
|
|
* @param dest
|
|
* will hold the result
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @return dest
|
|
*/
|
|
Matrix4d orthoSymmetricLH(double width, double height, double zNear, double zFar, boolean zZeroToOne, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a symmetric orthographic projection transformation for a left-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, Matrix4d) orthoLH()} with
|
|
* <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* orthographic projection transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
|
|
*
|
|
* @param width
|
|
* the distance between the right and left frustum edges
|
|
* @param height
|
|
* the distance between the top and bottom frustum edges
|
|
* @param zNear
|
|
* near clipping plane distance
|
|
* @param zFar
|
|
* far clipping plane distance
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d orthoSymmetricLH(double width, double height, double zNear, double zFar, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an orthographic projection transformation for a right-handed coordinate system
|
|
* to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, Matrix4d) ortho()} with
|
|
* <code>zNear=-1</code> and <code>zFar=+1</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* orthographic projection transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
|
|
*
|
|
* @see #ortho(double, double, double, double, double, double, Matrix4d)
|
|
*
|
|
* @param left
|
|
* the distance from the center to the left frustum edge
|
|
* @param right
|
|
* the distance from the center to the right frustum edge
|
|
* @param bottom
|
|
* the distance from the center to the bottom frustum edge
|
|
* @param top
|
|
* the distance from the center to the top frustum edge
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d ortho2D(double left, double right, double bottom, double top, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an orthographic projection transformation for a left-handed coordinate system to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, Matrix4d) orthoLH()} with
|
|
* <code>zNear=-1</code> and <code>zFar=+1</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* orthographic projection transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>
|
|
*
|
|
* @see #orthoLH(double, double, double, double, double, double, Matrix4d)
|
|
*
|
|
* @param left
|
|
* the distance from the center to the left frustum edge
|
|
* @param right
|
|
* the distance from the center to the right frustum edge
|
|
* @param bottom
|
|
* the distance from the center to the bottom frustum edge
|
|
* @param top
|
|
* the distance from the center to the top frustum edge
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d ortho2DLH(double left, double right, double bottom, double top, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a rotation transformation to this matrix to make <code>-z</code> point along <code>dir</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookalong rotation matrix,
|
|
* then the new matrix will be <code>M * L</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the
|
|
* lookalong rotation transformation will be applied first!
|
|
* <p>
|
|
* This is equivalent to calling
|
|
* {@link #lookAt(Vector3dc, Vector3dc, Vector3dc, Matrix4d) lookAt}
|
|
* with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>.
|
|
*
|
|
* @see #lookAlong(double, double, double, double, double, double, Matrix4d)
|
|
* @see #lookAt(Vector3dc, Vector3dc, Vector3dc, Matrix4d)
|
|
*
|
|
* @param dir
|
|
* the direction in space to look along
|
|
* @param up
|
|
* the direction of 'up'
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d lookAlong(Vector3dc dir, Vector3dc up, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a rotation transformation to this matrix to make <code>-z</code> point along <code>dir</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookalong rotation matrix,
|
|
* then the new matrix will be <code>M * L</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the
|
|
* lookalong rotation transformation will be applied first!
|
|
* <p>
|
|
* This is equivalent to calling
|
|
* {@link #lookAt(double, double, double, double, double, double, double, double, double, Matrix4d) lookAt()}
|
|
* with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>.
|
|
*
|
|
* @see #lookAt(double, double, double, double, double, double, double, double, double, Matrix4d)
|
|
*
|
|
* @param dirX
|
|
* the x-coordinate of the direction to look along
|
|
* @param dirY
|
|
* the y-coordinate of the direction to look along
|
|
* @param dirZ
|
|
* the z-coordinate of the direction to look along
|
|
* @param upX
|
|
* the x-coordinate of the up vector
|
|
* @param upY
|
|
* the y-coordinate of the up vector
|
|
* @param upZ
|
|
* the z-coordinate of the up vector
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a "lookat" transformation to this matrix for a right-handed coordinate system,
|
|
* that aligns <code>-z</code> with <code>center - eye</code> and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix,
|
|
* then the new matrix will be <code>M * L</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * L * v</code>,
|
|
* the lookat transformation will be applied first!
|
|
*
|
|
* @see #lookAt(double, double, double, double, double, double, double, double, double, Matrix4d)
|
|
*
|
|
* @param eye
|
|
* the position of the camera
|
|
* @param center
|
|
* the point in space to look at
|
|
* @param up
|
|
* the direction of 'up'
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d lookAt(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a "lookat" transformation to this matrix for a right-handed coordinate system,
|
|
* that aligns <code>-z</code> with <code>center - eye</code> and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix,
|
|
* then the new matrix will be <code>M * L</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * L * v</code>,
|
|
* the lookat transformation will be applied first!
|
|
*
|
|
* @see #lookAt(Vector3dc, Vector3dc, Vector3dc, Matrix4d)
|
|
*
|
|
* @param eyeX
|
|
* the x-coordinate of the eye/camera location
|
|
* @param eyeY
|
|
* the y-coordinate of the eye/camera location
|
|
* @param eyeZ
|
|
* the z-coordinate of the eye/camera location
|
|
* @param centerX
|
|
* the x-coordinate of the point to look at
|
|
* @param centerY
|
|
* the y-coordinate of the point to look at
|
|
* @param centerZ
|
|
* the z-coordinate of the point to look at
|
|
* @param upX
|
|
* the x-coordinate of the up vector
|
|
* @param upY
|
|
* the y-coordinate of the up vector
|
|
* @param upZ
|
|
* the z-coordinate of the up vector
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d lookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a "lookat" transformation to this matrix for a right-handed coordinate system,
|
|
* that aligns <code>-z</code> with <code>center - eye</code> and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes <code>this</code> to be a perspective transformation, obtained via
|
|
* {@link #frustum(double, double, double, double, double, double, Matrix4d) frustum()} or {@link #perspective(double, double, double, double, Matrix4d) perspective()} or
|
|
* one of their overloads.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix,
|
|
* then the new matrix will be <code>M * L</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * L * v</code>,
|
|
* the lookat transformation will be applied first!
|
|
*
|
|
* @param eyeX
|
|
* the x-coordinate of the eye/camera location
|
|
* @param eyeY
|
|
* the y-coordinate of the eye/camera location
|
|
* @param eyeZ
|
|
* the z-coordinate of the eye/camera location
|
|
* @param centerX
|
|
* the x-coordinate of the point to look at
|
|
* @param centerY
|
|
* the y-coordinate of the point to look at
|
|
* @param centerZ
|
|
* the z-coordinate of the point to look at
|
|
* @param upX
|
|
* the x-coordinate of the up vector
|
|
* @param upY
|
|
* the y-coordinate of the up vector
|
|
* @param upZ
|
|
* the z-coordinate of the up vector
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d lookAtPerspective(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a "lookat" transformation to this matrix for a left-handed coordinate system,
|
|
* that aligns <code>+z</code> with <code>center - eye</code> and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix,
|
|
* then the new matrix will be <code>M * L</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * L * v</code>,
|
|
* the lookat transformation will be applied first!
|
|
*
|
|
* @param eye
|
|
* the position of the camera
|
|
* @param center
|
|
* the point in space to look at
|
|
* @param up
|
|
* the direction of 'up'
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d lookAtLH(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a "lookat" transformation to this matrix for a left-handed coordinate system,
|
|
* that aligns <code>+z</code> with <code>center - eye</code> and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix,
|
|
* then the new matrix will be <code>M * L</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * L * v</code>,
|
|
* the lookat transformation will be applied first!
|
|
*
|
|
* @see #lookAtLH(Vector3dc, Vector3dc, Vector3dc, Matrix4d)
|
|
*
|
|
* @param eyeX
|
|
* the x-coordinate of the eye/camera location
|
|
* @param eyeY
|
|
* the y-coordinate of the eye/camera location
|
|
* @param eyeZ
|
|
* the z-coordinate of the eye/camera location
|
|
* @param centerX
|
|
* the x-coordinate of the point to look at
|
|
* @param centerY
|
|
* the y-coordinate of the point to look at
|
|
* @param centerZ
|
|
* the z-coordinate of the point to look at
|
|
* @param upX
|
|
* the x-coordinate of the up vector
|
|
* @param upY
|
|
* the y-coordinate of the up vector
|
|
* @param upZ
|
|
* the z-coordinate of the up vector
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d lookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a "lookat" transformation to this matrix for a left-handed coordinate system,
|
|
* that aligns <code>+z</code> with <code>center - eye</code> and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes <code>this</code> to be a perspective transformation, obtained via
|
|
* {@link #frustumLH(double, double, double, double, double, double, Matrix4d) frustumLH()} or {@link #perspectiveLH(double, double, double, double, Matrix4d) perspectiveLH()} or
|
|
* one of their overloads.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix,
|
|
* then the new matrix will be <code>M * L</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * L * v</code>,
|
|
* the lookat transformation will be applied first!
|
|
*
|
|
* @param eyeX
|
|
* the x-coordinate of the eye/camera location
|
|
* @param eyeY
|
|
* the y-coordinate of the eye/camera location
|
|
* @param eyeZ
|
|
* the z-coordinate of the eye/camera location
|
|
* @param centerX
|
|
* the x-coordinate of the point to look at
|
|
* @param centerY
|
|
* the y-coordinate of the point to look at
|
|
* @param centerZ
|
|
* the z-coordinate of the point to look at
|
|
* @param upX
|
|
* the x-coordinate of the up vector
|
|
* @param upY
|
|
* the y-coordinate of the up vector
|
|
* @param upZ
|
|
* the z-coordinate of the up vector
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d lookAtPerspectiveLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d dest);
|
|
|
|
/**
|
|
* This method is equivalent to calling: <code>translate(w-1-2*x, h-1-2*y, 0, dest).scale(w, h, 1)</code>
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>T</code> the created transformation matrix,
|
|
* then the new matrix will be <code>M * T</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * T * v</code>, the
|
|
* created transformation will be applied first!
|
|
*
|
|
* @param x
|
|
* the tile's x coordinate/index (should be in <code>[0..w)</code>)
|
|
* @param y
|
|
* the tile's y coordinate/index (should be in <code>[0..h)</code>)
|
|
* @param w
|
|
* the number of tiles along the x axis
|
|
* @param h
|
|
* the number of tiles along the y axis
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d tile(int x, int y, int w, int h, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a symmetric perspective projection frustum transformation for a right-handed coordinate system
|
|
* using the given NDC z range to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param fovy
|
|
* the vertical field of view in radians (must be greater than zero and less than {@link Math#PI PI})
|
|
* @param aspect
|
|
* the aspect ratio (i.e. width / height; must be greater than zero)
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param dest
|
|
* will hold the result
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @return dest
|
|
*/
|
|
Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, boolean zZeroToOne, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a symmetric perspective projection frustum transformation for a right-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param fovy
|
|
* the vertical field of view in radians (must be greater than zero and less than {@link Math#PI PI})
|
|
* @param aspect
|
|
* the aspect ratio (i.e. width / height; must be greater than zero)
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a symmetric perspective projection frustum transformation for a right-handed coordinate system
|
|
* using the given NDC z range to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param width
|
|
* the width of the near frustum plane
|
|
* @param height
|
|
* the height of the near frustum plane
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param dest
|
|
* will hold the result
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @return dest
|
|
*/
|
|
Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, boolean zZeroToOne, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a symmetric perspective projection frustum transformation for a right-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param width
|
|
* the width of the near frustum plane
|
|
* @param height
|
|
* the height of the near frustum plane
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a symmetric perspective projection frustum transformation using for a right-handed coordinate system
|
|
* the given NDC z range to this matrix.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param width
|
|
* the width of the near frustum plane
|
|
* @param height
|
|
* the height of the near frustum plane
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @return this
|
|
*/
|
|
Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, boolean zZeroToOne);
|
|
|
|
/**
|
|
* Apply a symmetric perspective projection frustum transformation for a right-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param width
|
|
* the width of the near frustum plane
|
|
* @param height
|
|
* the height of the near frustum plane
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @return this
|
|
*/
|
|
Matrix4d perspectiveRect(double width, double height, double zNear, double zFar);
|
|
|
|
/**
|
|
* Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system
|
|
* using the given NDC z range to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between
|
|
* the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code>
|
|
* is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane
|
|
* is parallel to the XZ-plane.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param fovy
|
|
* the vertical field of view in radians (must be greater than zero and less than {@link Math#PI PI})
|
|
* @param offAngleX
|
|
* the horizontal angle between the line of sight and the line crossing the center of the near and far frustum planes
|
|
* @param offAngleY
|
|
* the vertical angle between the line of sight and the line crossing the center of the near and far frustum planes
|
|
* @param aspect
|
|
* the aspect ratio (i.e. width / height; must be greater than zero)
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param dest
|
|
* will hold the result
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @return dest
|
|
*/
|
|
Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, boolean zZeroToOne, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between
|
|
* the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code>
|
|
* is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane
|
|
* is parallel to the XZ-plane.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param fovy
|
|
* the vertical field of view in radians (must be greater than zero and less than {@link Math#PI PI})
|
|
* @param offAngleX
|
|
* the horizontal angle between the line of sight and the line crossing the center of the near and far frustum planes
|
|
* @param offAngleY
|
|
* the vertical angle between the line of sight and the line crossing the center of the near and far frustum planes
|
|
* @param aspect
|
|
* the aspect ratio (i.e. width / height; must be greater than zero)
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an asymmetric off-center perspective projection frustum transformation using for a right-handed coordinate system
|
|
* the given NDC z range to this matrix.
|
|
* <p>
|
|
* The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between
|
|
* the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code>
|
|
* is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane
|
|
* is parallel to the XZ-plane.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param fovy
|
|
* the vertical field of view in radians (must be greater than zero and less than {@link Math#PI PI})
|
|
* @param offAngleX
|
|
* the horizontal angle between the line of sight and the line crossing the center of the near and far frustum planes
|
|
* @param offAngleY
|
|
* the vertical angle between the line of sight and the line crossing the center of the near and far frustum planes
|
|
* @param aspect
|
|
* the aspect ratio (i.e. width / height; must be greater than zero)
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @return this
|
|
*/
|
|
Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, boolean zZeroToOne);
|
|
|
|
/**
|
|
* Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix.
|
|
* <p>
|
|
* The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between
|
|
* the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code>
|
|
* is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane
|
|
* is parallel to the XZ-plane.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param fovy
|
|
* the vertical field of view in radians (must be greater than zero and less than {@link Math#PI PI})
|
|
* @param offAngleX
|
|
* the horizontal angle between the line of sight and the line crossing the center of the near and far frustum planes
|
|
* @param offAngleY
|
|
* the vertical angle between the line of sight and the line crossing the center of the near and far frustum planes
|
|
* @param aspect
|
|
* the aspect ratio (i.e. width / height; must be greater than zero)
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @return this
|
|
*/
|
|
Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar);
|
|
|
|
/**
|
|
* Apply a symmetric perspective projection frustum transformation for a left-handed coordinate system
|
|
* using the given NDC z range to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param fovy
|
|
* the vertical field of view in radians (must be greater than zero and less than {@link Math#PI PI})
|
|
* @param aspect
|
|
* the aspect ratio (i.e. width / height; must be greater than zero)
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, boolean zZeroToOne, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a symmetric perspective projection frustum transformation for a left-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix,
|
|
* then the new matrix will be <code>M * P</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * P * v</code>,
|
|
* the perspective projection will be applied first!
|
|
*
|
|
* @param fovy
|
|
* the vertical field of view in radians (must be greater than zero and less than {@link Math#PI PI})
|
|
* @param aspect
|
|
* the aspect ratio (i.e. width / height; must be greater than zero)
|
|
* @param zNear
|
|
* near clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, Matrix4d dest);
|
|
|
|
/**
|
|
* 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 <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>F</code> the frustum matrix,
|
|
* then the new matrix will be <code>M * F</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * F * v</code>,
|
|
* the frustum transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
|
|
*
|
|
* @param left
|
|
* the distance along the x-axis to the left frustum edge
|
|
* @param right
|
|
* the distance along the x-axis to the right frustum edge
|
|
* @param bottom
|
|
* the distance along the y-axis to the bottom frustum edge
|
|
* @param top
|
|
* the distance along the y-axis to the top frustum edge
|
|
* @param zNear
|
|
* near clipping plane distance. This value must be greater than zero.
|
|
* If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. This value must be greater than zero.
|
|
* If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, boolean zZeroToOne, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an arbitrary perspective projection frustum transformation for a right-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>F</code> the frustum matrix,
|
|
* then the new matrix will be <code>M * F</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * F * v</code>,
|
|
* the frustum transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
|
|
*
|
|
* @param left
|
|
* the distance along the x-axis to the left frustum edge
|
|
* @param right
|
|
* the distance along the x-axis to the right frustum edge
|
|
* @param bottom
|
|
* the distance along the y-axis to the bottom frustum edge
|
|
* @param top
|
|
* the distance along the y-axis to the top frustum edge
|
|
* @param zNear
|
|
* near clipping plane distance. This value must be greater than zero.
|
|
* If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. This value must be greater than zero.
|
|
* If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d dest);
|
|
|
|
/**
|
|
* 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 <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>F</code> the frustum matrix,
|
|
* then the new matrix will be <code>M * F</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * F * v</code>,
|
|
* the frustum transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
|
|
*
|
|
* @param left
|
|
* the distance along the x-axis to the left frustum edge
|
|
* @param right
|
|
* the distance along the x-axis to the right frustum edge
|
|
* @param bottom
|
|
* the distance along the y-axis to the bottom frustum edge
|
|
* @param top
|
|
* the distance along the y-axis to the top frustum edge
|
|
* @param zNear
|
|
* near clipping plane distance. This value must be greater than zero.
|
|
* If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. This value must be greater than zero.
|
|
* If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zZeroToOne
|
|
* whether to use Vulkan's and Direct3D's NDC z range of <code>[0..+1]</code> when <code>true</code>
|
|
* or whether to use OpenGL's NDC z range of <code>[-1..+1]</code> when <code>false</code>
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, boolean zZeroToOne, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an arbitrary perspective projection frustum transformation for a left-handed coordinate system
|
|
* using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>F</code> the frustum matrix,
|
|
* then the new matrix will be <code>M * F</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * F * v</code>,
|
|
* the frustum transformation will be applied first!
|
|
* <p>
|
|
* Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>
|
|
*
|
|
* @param left
|
|
* the distance along the x-axis to the left frustum edge
|
|
* @param right
|
|
* the distance along the x-axis to the right frustum edge
|
|
* @param bottom
|
|
* the distance along the y-axis to the bottom frustum edge
|
|
* @param top
|
|
* the distance along the y-axis to the top frustum edge
|
|
* @param zNear
|
|
* near clipping plane distance. This value must be greater than zero.
|
|
* If the special value {@link Double#POSITIVE_INFINITY} is used, the near clipping plane will be at positive infinity.
|
|
* In that case, <code>zFar</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param zFar
|
|
* far clipping plane distance. This value must be greater than zero.
|
|
* If the special value {@link Double#POSITIVE_INFINITY} is used, the far clipping plane will be at positive infinity.
|
|
* In that case, <code>zNear</code> may not also be {@link Double#POSITIVE_INFINITY}.
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d dest);
|
|
|
|
/**
|
|
* Calculate a frustum plane of <code>this</code> matrix, which
|
|
* can be a projection matrix or a combined modelview-projection matrix, and store the result
|
|
* in the given <code>dest</code>.
|
|
* <p>
|
|
* Generally, this method computes the frustum plane in the local frame of
|
|
* any coordinate system that existed before <code>this</code>
|
|
* transformation was applied to it in order to yield homogeneous clipping space.
|
|
* <p>
|
|
* The frustum plane will be given in the form of a general plane equation:
|
|
* <code>a*x + b*y + c*z + d = 0</code>, where the given {@link Vector4d} components will
|
|
* hold the <code>(a, b, c, d)</code> values of the equation.
|
|
* <p>
|
|
* The plane normal, which is <code>(a, b, c)</code>, is directed "inwards" of the frustum.
|
|
* Any plane/point test using <code>a*x + b*y + c*z + d</code> therefore will yield a result greater than zero
|
|
* if the point is within the frustum (i.e. at the <i>positive</i> side of the frustum plane).
|
|
* <p>
|
|
* For performing frustum culling, the class {@link FrustumIntersection} should be used instead of
|
|
* manually obtaining the frustum planes and testing them against points, spheres or axis-aligned boxes.
|
|
* <p>
|
|
* Reference: <a href="http://gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdf">
|
|
* Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix</a>
|
|
*
|
|
* @param plane
|
|
* one of the six possible planes, given as numeric constants
|
|
* {@link #PLANE_NX}, {@link #PLANE_PX},
|
|
* {@link #PLANE_NY}, {@link #PLANE_PY},
|
|
* {@link #PLANE_NZ} and {@link #PLANE_PZ}
|
|
* @param dest
|
|
* will hold the computed plane equation.
|
|
* The plane equation will be normalized, meaning that <code>(a, b, c)</code> will be a unit vector
|
|
* @return dest
|
|
*/
|
|
Vector4d frustumPlane(int plane, Vector4d dest);
|
|
|
|
/**
|
|
* Compute the corner coordinates of the frustum defined by <code>this</code> matrix, which
|
|
* can be a projection matrix or a combined modelview-projection matrix, and store the result
|
|
* in the given <code>point</code>.
|
|
* <p>
|
|
* Generally, this method computes the frustum corners in the local frame of
|
|
* any coordinate system that existed before <code>this</code>
|
|
* transformation was applied to it in order to yield homogeneous clipping space.
|
|
* <p>
|
|
* Reference: <a href="http://geomalgorithms.com/a05-_intersect-1.html">http://geomalgorithms.com</a>
|
|
* <p>
|
|
* Reference: <a href="http://gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdf">
|
|
* Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix</a>
|
|
*
|
|
* @param corner
|
|
* one of the eight possible corners, given as numeric constants
|
|
* {@link #CORNER_NXNYNZ}, {@link #CORNER_PXNYNZ}, {@link #CORNER_PXPYNZ}, {@link #CORNER_NXPYNZ},
|
|
* {@link #CORNER_PXNYPZ}, {@link #CORNER_NXNYPZ}, {@link #CORNER_NXPYPZ}, {@link #CORNER_PXPYPZ}
|
|
* @param point
|
|
* will hold the resulting corner point coordinates
|
|
* @return point
|
|
*/
|
|
Vector3d frustumCorner(int corner, Vector3d point);
|
|
|
|
/**
|
|
* Compute the eye/origin of the perspective frustum transformation defined by <code>this</code> matrix,
|
|
* which can be a projection matrix or a combined modelview-projection matrix, and store the result
|
|
* in the given <code>origin</code>.
|
|
* <p>
|
|
* Note that this method will only work using perspective projections obtained via one of the
|
|
* perspective methods, such as {@link #perspective(double, double, double, double, Matrix4d) perspective()}
|
|
* or {@link #frustum(double, double, double, double, double, double, Matrix4d) frustum()}.
|
|
* <p>
|
|
* Generally, this method computes the origin in the local frame of
|
|
* any coordinate system that existed before <code>this</code>
|
|
* transformation was applied to it in order to yield homogeneous clipping space.
|
|
* <p>
|
|
* This method is equivalent to calling: <code>invert(new Matrix4d()).transformProject(0, 0, -1, 0, origin)</code>
|
|
* and in the case of an already available inverse of <code>this</code> matrix, the method {@link #perspectiveInvOrigin(Vector3d)}
|
|
* on the inverse of the matrix should be used instead.
|
|
* <p>
|
|
* Reference: <a href="http://geomalgorithms.com/a05-_intersect-1.html">http://geomalgorithms.com</a>
|
|
* <p>
|
|
* Reference: <a href="http://gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdf">
|
|
* Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix</a>
|
|
*
|
|
* @param origin
|
|
* will hold the origin of the coordinate system before applying <code>this</code>
|
|
* perspective projection transformation
|
|
* @return origin
|
|
*/
|
|
Vector3d perspectiveOrigin(Vector3d origin);
|
|
|
|
/**
|
|
* Compute the eye/origin of the inverse of the perspective frustum transformation defined by <code>this</code> matrix,
|
|
* which can be the inverse of a projection matrix or the inverse of a combined modelview-projection matrix, and store the result
|
|
* in the given <code>dest</code>.
|
|
* <p>
|
|
* Note that this method will only work using perspective projections obtained via one of the
|
|
* perspective methods, such as {@link #perspective(double, double, double, double, Matrix4d) perspective()}
|
|
* or {@link #frustum(double, double, double, double, double, double, Matrix4d) frustum()}.
|
|
* <p>
|
|
* If the inverse of the modelview-projection matrix is not available, then calling {@link #perspectiveOrigin(Vector3d)}
|
|
* on the original modelview-projection matrix is preferred.
|
|
*
|
|
* @see #perspectiveOrigin(Vector3d)
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Vector3d perspectiveInvOrigin(Vector3d dest);
|
|
|
|
/**
|
|
* Return the vertical field-of-view angle in radians of this perspective transformation matrix.
|
|
* <p>
|
|
* Note that this method will only work using perspective projections obtained via one of the
|
|
* perspective methods, such as {@link #perspective(double, double, double, double, Matrix4d) perspective()}
|
|
* or {@link #frustum(double, double, double, double, double, double, Matrix4d) frustum()}.
|
|
* <p>
|
|
* For orthogonal transformations this method will return <code>0.0</code>.
|
|
* <p>
|
|
* Reference: <a href="http://gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdf">
|
|
* Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix</a>
|
|
*
|
|
* @return the vertical field-of-view angle in radians
|
|
*/
|
|
double perspectiveFov();
|
|
|
|
/**
|
|
* Extract the near clip plane distance from <code>this</code> perspective projection matrix.
|
|
* <p>
|
|
* This method only works if <code>this</code> is a perspective projection matrix, for example obtained via {@link #perspective(double, double, double, double, Matrix4d)}.
|
|
*
|
|
* @return the near clip plane distance
|
|
*/
|
|
double perspectiveNear();
|
|
|
|
/**
|
|
* Extract the far clip plane distance from <code>this</code> perspective projection matrix.
|
|
* <p>
|
|
* This method only works if <code>this</code> is a perspective projection matrix, for example obtained via {@link #perspective(double, double, double, double, Matrix4d)}.
|
|
*
|
|
* @return the far clip plane distance
|
|
*/
|
|
double perspectiveFar();
|
|
|
|
/**
|
|
* Obtain the direction of a ray starting at the center of the coordinate system and going
|
|
* through the near frustum plane.
|
|
* <p>
|
|
* This method computes the <code>dir</code> vector in the local frame of
|
|
* any coordinate system that existed before <code>this</code>
|
|
* transformation was applied to it in order to yield homogeneous clipping space.
|
|
* <p>
|
|
* The parameters <code>x</code> and <code>y</code> are used to interpolate the generated ray direction
|
|
* from the bottom-left to the top-right frustum corners.
|
|
* <p>
|
|
* For optimal efficiency when building many ray directions over the whole frustum,
|
|
* it is recommended to use this method only in order to compute the four corner rays at
|
|
* <code>(0, 0)</code>, <code>(1, 0)</code>, <code>(0, 1)</code> and <code>(1, 1)</code>
|
|
* and then bilinearly interpolating between them; or to use the {@link FrustumRayBuilder}.
|
|
* <p>
|
|
* Reference: <a href="http://gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdf">
|
|
* Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix</a>
|
|
*
|
|
* @param x
|
|
* the interpolation factor along the left-to-right frustum planes, within <code>[0..1]</code>
|
|
* @param y
|
|
* the interpolation factor along the bottom-to-top frustum planes, within <code>[0..1]</code>
|
|
* @param dir
|
|
* will hold the normalized ray direction in the local frame of the coordinate system before
|
|
* transforming to homogeneous clipping space using <code>this</code> matrix
|
|
* @return dir
|
|
*/
|
|
Vector3d frustumRayDir(double x, double y, Vector3d dir);
|
|
|
|
/**
|
|
* Obtain the direction of <code>+Z</code> before the transformation represented by <code>this</code> matrix is applied.
|
|
* <p>
|
|
* This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
|
|
* that is transformed to <code>+Z</code> by <code>this</code> matrix.
|
|
* <p>
|
|
* This method is equivalent to the following code:
|
|
* <pre>
|
|
* Matrix4d inv = new Matrix4d(this).invert();
|
|
* inv.transformDirection(dir.set(0, 0, 1)).normalize();
|
|
* </pre>
|
|
* If <code>this</code> is already an orthogonal matrix, then consider using {@link #normalizedPositiveZ(Vector3d)} instead.
|
|
* <p>
|
|
* Reference: <a href="http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/threeD/">http://www.euclideanspace.com</a>
|
|
*
|
|
* @param dir
|
|
* will hold the direction of <code>+Z</code>
|
|
* @return dir
|
|
*/
|
|
Vector3d positiveZ(Vector3d dir);
|
|
|
|
/**
|
|
* Obtain the direction of <code>+Z</code> before the transformation represented by <code>this</code> <i>orthogonal</i> matrix is applied.
|
|
* This method only produces correct results if <code>this</code> is an <i>orthogonal</i> matrix.
|
|
* <p>
|
|
* This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
|
|
* that is transformed to <code>+Z</code> by <code>this</code> matrix.
|
|
* <p>
|
|
* This method is equivalent to the following code:
|
|
* <pre>
|
|
* Matrix4d inv = new Matrix4d(this).transpose();
|
|
* inv.transformDirection(dir.set(0, 0, 1));
|
|
* </pre>
|
|
* <p>
|
|
* Reference: <a href="http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/threeD/">http://www.euclideanspace.com</a>
|
|
*
|
|
* @param dir
|
|
* will hold the direction of <code>+Z</code>
|
|
* @return dir
|
|
*/
|
|
Vector3d normalizedPositiveZ(Vector3d dir);
|
|
|
|
/**
|
|
* Obtain the direction of <code>+X</code> before the transformation represented by <code>this</code> matrix is applied.
|
|
* <p>
|
|
* This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
|
|
* that is transformed to <code>+X</code> by <code>this</code> matrix.
|
|
* <p>
|
|
* This method is equivalent to the following code:
|
|
* <pre>
|
|
* Matrix4d inv = new Matrix4d(this).invert();
|
|
* inv.transformDirection(dir.set(1, 0, 0)).normalize();
|
|
* </pre>
|
|
* If <code>this</code> is already an orthogonal matrix, then consider using {@link #normalizedPositiveX(Vector3d)} instead.
|
|
* <p>
|
|
* Reference: <a href="http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/threeD/">http://www.euclideanspace.com</a>
|
|
*
|
|
* @param dir
|
|
* will hold the direction of <code>+X</code>
|
|
* @return dir
|
|
*/
|
|
Vector3d positiveX(Vector3d dir);
|
|
|
|
/**
|
|
* Obtain the direction of <code>+X</code> before the transformation represented by <code>this</code> <i>orthogonal</i> matrix is applied.
|
|
* This method only produces correct results if <code>this</code> is an <i>orthogonal</i> matrix.
|
|
* <p>
|
|
* This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
|
|
* that is transformed to <code>+X</code> by <code>this</code> matrix.
|
|
* <p>
|
|
* This method is equivalent to the following code:
|
|
* <pre>
|
|
* Matrix4d inv = new Matrix4d(this).transpose();
|
|
* inv.transformDirection(dir.set(1, 0, 0));
|
|
* </pre>
|
|
* <p>
|
|
* Reference: <a href="http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/threeD/">http://www.euclideanspace.com</a>
|
|
*
|
|
* @param dir
|
|
* will hold the direction of <code>+X</code>
|
|
* @return dir
|
|
*/
|
|
Vector3d normalizedPositiveX(Vector3d dir);
|
|
|
|
/**
|
|
* Obtain the direction of <code>+Y</code> before the transformation represented by <code>this</code> matrix is applied.
|
|
* <p>
|
|
* This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
|
|
* that is transformed to <code>+Y</code> by <code>this</code> matrix.
|
|
* <p>
|
|
* This method is equivalent to the following code:
|
|
* <pre>
|
|
* Matrix4d inv = new Matrix4d(this).invert();
|
|
* inv.transformDirection(dir.set(0, 1, 0)).normalize();
|
|
* </pre>
|
|
* If <code>this</code> is already an orthogonal matrix, then consider using {@link #normalizedPositiveY(Vector3d)} instead.
|
|
* <p>
|
|
* Reference: <a href="http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/threeD/">http://www.euclideanspace.com</a>
|
|
*
|
|
* @param dir
|
|
* will hold the direction of <code>+Y</code>
|
|
* @return dir
|
|
*/
|
|
Vector3d positiveY(Vector3d dir);
|
|
|
|
/**
|
|
* Obtain the direction of <code>+Y</code> before the transformation represented by <code>this</code> <i>orthogonal</i> matrix is applied.
|
|
* This method only produces correct results if <code>this</code> is an <i>orthogonal</i> matrix.
|
|
* <p>
|
|
* This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
|
|
* that is transformed to <code>+Y</code> by <code>this</code> matrix.
|
|
* <p>
|
|
* This method is equivalent to the following code:
|
|
* <pre>
|
|
* Matrix4d inv = new Matrix4d(this).transpose();
|
|
* inv.transformDirection(dir.set(0, 1, 0));
|
|
* </pre>
|
|
* <p>
|
|
* Reference: <a href="http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/threeD/">http://www.euclideanspace.com</a>
|
|
*
|
|
* @param dir
|
|
* will hold the direction of <code>+Y</code>
|
|
* @return dir
|
|
*/
|
|
Vector3d normalizedPositiveY(Vector3d dir);
|
|
|
|
/**
|
|
* Obtain the position that gets transformed to the origin by <code>this</code> {@link #isAffine() affine} matrix.
|
|
* This can be used to get the position of the "camera" from a given <i>view</i> transformation matrix.
|
|
* <p>
|
|
* This method only works with {@link #isAffine() affine} matrices.
|
|
* <p>
|
|
* This method is equivalent to the following code:
|
|
* <pre>
|
|
* Matrix4f inv = new Matrix4f(this).invertAffine();
|
|
* inv.transformPosition(origin.set(0, 0, 0));
|
|
* </pre>
|
|
*
|
|
* @param origin
|
|
* will hold the position transformed to the origin
|
|
* @return origin
|
|
*/
|
|
Vector3d originAffine(Vector3d origin);
|
|
|
|
/**
|
|
* Obtain the position that gets transformed to the origin by <code>this</code> matrix.
|
|
* This can be used to get the position of the "camera" from a given <i>view/projection</i> transformation matrix.
|
|
* <p>
|
|
* This method is equivalent to the following code:
|
|
* <pre>
|
|
* Matrix4f inv = new Matrix4f(this).invert();
|
|
* inv.transformPosition(origin.set(0, 0, 0));
|
|
* </pre>
|
|
*
|
|
* @param origin
|
|
* will hold the position transformed to the origin
|
|
* @return origin
|
|
*/
|
|
Vector3d origin(Vector3d origin);
|
|
|
|
/**
|
|
* Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation
|
|
* <code>x*a + y*b + z*c + d = 0</code> as if casting a shadow from a given light position/direction <code>light</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>light.w</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix,
|
|
* then the new matrix will be <code>M * S</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the
|
|
* shadow projection will be applied first!
|
|
* <p>
|
|
* Reference: <a href="ftp://ftp.sgi.com/opengl/contrib/blythe/advanced99/notes/node192.html">ftp.sgi.com</a>
|
|
*
|
|
* @param light
|
|
* the light's vector
|
|
* @param a
|
|
* the x factor in the plane equation
|
|
* @param b
|
|
* the y factor in the plane equation
|
|
* @param c
|
|
* the z factor in the plane equation
|
|
* @param d
|
|
* the constant in the plane equation
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d shadow(Vector4dc light, double a, double b, double c, double d, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation
|
|
* <code>x*a + y*b + z*c + d = 0</code> as if casting a shadow from a given light position/direction <code>(lightX, lightY, lightZ, lightW)</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>lightW</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix,
|
|
* then the new matrix will be <code>M * S</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the
|
|
* shadow projection will be applied first!
|
|
* <p>
|
|
* Reference: <a href="ftp://ftp.sgi.com/opengl/contrib/blythe/advanced99/notes/node192.html">ftp.sgi.com</a>
|
|
*
|
|
* @param lightX
|
|
* the x-component of the light's vector
|
|
* @param lightY
|
|
* the y-component of the light's vector
|
|
* @param lightZ
|
|
* the z-component of the light's vector
|
|
* @param lightW
|
|
* the w-component of the light's vector
|
|
* @param a
|
|
* the x factor in the plane equation
|
|
* @param b
|
|
* the y factor in the plane equation
|
|
* @param c
|
|
* the z factor in the plane equation
|
|
* @param d
|
|
* the constant in the plane equation
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d shadow(double lightX, double lightY, double lightZ, double lightW, double a, double b, double c, double d, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a projection transformation to this matrix that projects onto the plane with the general plane equation
|
|
* <code>y = 0</code> as if casting a shadow from a given light position/direction <code>light</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* Before the shadow projection is applied, the plane is transformed via the specified <code>planeTransformation</code>.
|
|
* <p>
|
|
* If <code>light.w</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix,
|
|
* then the new matrix will be <code>M * S</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the
|
|
* shadow projection will be applied first!
|
|
*
|
|
* @param light
|
|
* the light's vector
|
|
* @param planeTransform
|
|
* the transformation to transform the implied plane <code>y = 0</code> before applying the projection
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d shadow(Vector4dc light, Matrix4dc planeTransform, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a projection transformation to this matrix that projects onto the plane with the general plane equation
|
|
* <code>y = 0</code> as if casting a shadow from a given light position/direction <code>(lightX, lightY, lightZ, lightW)</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* Before the shadow projection is applied, the plane is transformed via the specified <code>planeTransformation</code>.
|
|
* <p>
|
|
* If <code>lightW</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix,
|
|
* then the new matrix will be <code>M * S</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the
|
|
* shadow projection will be applied first!
|
|
*
|
|
* @param lightX
|
|
* the x-component of the light vector
|
|
* @param lightY
|
|
* the y-component of the light vector
|
|
* @param lightZ
|
|
* the z-component of the light vector
|
|
* @param lightW
|
|
* the w-component of the light vector
|
|
* @param planeTransform
|
|
* the transformation to transform the implied plane <code>y = 0</code> before applying the projection
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4dc planeTransform, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a picking transformation to this matrix using the given window coordinates <code>(x, y)</code> as the pick center
|
|
* and the given <code>(width, height)</code> as the size of the picking region in window coordinates, and store the result
|
|
* in <code>dest</code>.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the picking region center in window coordinates
|
|
* @param y
|
|
* the y coordinate of the picking region center in window coordinates
|
|
* @param width
|
|
* the width of the picking region in window coordinates
|
|
* @param height
|
|
* the height of the picking region in window coordinates
|
|
* @param viewport
|
|
* the viewport described by <code>[x, y, width, height]</code>
|
|
* @param dest
|
|
* the destination matrix, which will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d pick(double x, double y, double width, double height, int[] viewport, Matrix4d dest);
|
|
|
|
/**
|
|
* Determine whether this matrix describes an affine transformation. This is the case iff its last row is equal to <code>(0, 0, 0, 1)</code>.
|
|
*
|
|
* @return <code>true</code> iff this matrix is affine; <code>false</code> otherwise
|
|
*/
|
|
boolean isAffine();
|
|
|
|
/**
|
|
* Apply an arcball view transformation to this matrix with the given <code>radius</code> and center <code>(centerX, centerY, centerZ)</code>
|
|
* position of the arcball and the specified X and Y rotation angles, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method is equivalent to calling: <code>translate(0, 0, -radius, dest).rotateX(angleX).rotateY(angleY).translate(-centerX, -centerY, -centerZ)</code>
|
|
*
|
|
* @param radius
|
|
* the arcball radius
|
|
* @param centerX
|
|
* the x coordinate of the center position of the arcball
|
|
* @param centerY
|
|
* the y coordinate of the center position of the arcball
|
|
* @param centerZ
|
|
* the z coordinate of the center position of the arcball
|
|
* @param angleX
|
|
* the rotation angle around the X axis in radians
|
|
* @param angleY
|
|
* the rotation angle around the Y axis in radians
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d arcball(double radius, double centerX, double centerY, double centerZ, double angleX, double angleY, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply an arcball view transformation to this matrix with the given <code>radius</code> and <code>center</code>
|
|
* position of the arcball and the specified X and Y rotation angles, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method is equivalent to calling: <code>translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-center.x, -center.y, -center.z)</code>
|
|
*
|
|
* @param radius
|
|
* the arcball radius
|
|
* @param center
|
|
* the center position of the arcball
|
|
* @param angleX
|
|
* the rotation angle around the X axis in radians
|
|
* @param angleY
|
|
* the rotation angle around the Y axis in radians
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d arcball(double radius, Vector3dc center, double angleX, double angleY, Matrix4d dest);
|
|
|
|
/**
|
|
* Compute the <i>range matrix</i> for the Projected Grid transformation as described in chapter "2.4.2 Creating the range conversion matrix"
|
|
* of the paper <a href="http://fileadmin.cs.lth.se/graphics/theses/projects/projgrid/projgrid-lq.pdf">Real-time water rendering - Introducing the projected grid concept</a>
|
|
* based on the <i>inverse</i> of the view-projection matrix which is assumed to be <code>this</code>, and store that range matrix into <code>dest</code>.
|
|
* <p>
|
|
* If the projected grid will not be visible then this method returns <code>null</code>.
|
|
* <p>
|
|
* This method uses the <code>y = 0</code> plane for the projection.
|
|
*
|
|
* @param projector
|
|
* the projector view-projection transformation
|
|
* @param sLower
|
|
* the lower (smallest) Y-coordinate which any transformed vertex might have while still being visible on the projected grid
|
|
* @param sUpper
|
|
* the upper (highest) Y-coordinate which any transformed vertex might have while still being visible on the projected grid
|
|
* @param dest
|
|
* will hold the resulting range matrix
|
|
* @return the computed range matrix; or <code>null</code> if the projected grid will not be visible
|
|
*/
|
|
Matrix4d projectedGridRange(Matrix4dc projector, double sLower, double sUpper, Matrix4d dest);
|
|
|
|
/**
|
|
* Change the near and far clip plane distances of <code>this</code> perspective frustum transformation matrix
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This method only works if <code>this</code> is a perspective projection frustum transformation, for example obtained
|
|
* via {@link #perspective(double, double, double, double, Matrix4d) perspective()} or {@link #frustum(double, double, double, double, double, double, Matrix4d) frustum()}.
|
|
*
|
|
* @see #perspective(double, double, double, double, Matrix4d)
|
|
* @see #frustum(double, double, double, double, double, double, Matrix4d)
|
|
*
|
|
* @param near
|
|
* the new near clip plane distance
|
|
* @param far
|
|
* the new far clip plane distance
|
|
* @param dest
|
|
* will hold the resulting matrix
|
|
* @return dest
|
|
*/
|
|
Matrix4d perspectiveFrustumSlice(double near, double far, Matrix4d dest);
|
|
|
|
/**
|
|
* Build an ortographic projection transformation that fits the view-projection transformation represented by <code>this</code>
|
|
* into the given affine <code>view</code> transformation.
|
|
* <p>
|
|
* The transformation represented by <code>this</code> must be given as the {@link #invert(Matrix4d) inverse} of a typical combined camera view-projection
|
|
* transformation, whose projection can be either orthographic or perspective.
|
|
* <p>
|
|
* The <code>view</code> must be an {@link #isAffine() affine} transformation which in the application of Cascaded Shadow Maps is usually the light view transformation.
|
|
* It be obtained via any affine transformation or for example via {@link #lookAt(double, double, double, double, double, double, double, double, double, Matrix4d) lookAt()}.
|
|
* <p>
|
|
* Reference: <a href="http://developer.download.nvidia.com/SDK/10.5/opengl/screenshots/samples/cascaded_shadow_maps.html">OpenGL SDK - Cascaded Shadow Maps</a>
|
|
*
|
|
* @param view
|
|
* the view transformation to build a corresponding orthographic projection to fit the frustum of <code>this</code>
|
|
* @param dest
|
|
* will hold the crop projection transformation
|
|
* @return dest
|
|
*/
|
|
Matrix4d orthoCrop(Matrix4dc view, Matrix4d dest);
|
|
|
|
/**
|
|
* Transform the axis-aligned box given as the minimum corner <code>(minX, minY, minZ)</code> and maximum corner <code>(maxX, maxY, maxZ)</code>
|
|
* by <code>this</code> {@link #isAffine() affine} matrix and compute the axis-aligned box of the result whose minimum corner is stored in <code>outMin</code>
|
|
* and maximum corner stored in <code>outMax</code>.
|
|
* <p>
|
|
* Reference: <a href="http://dev.theomader.com/transform-bounding-boxes/">http://dev.theomader.com</a>
|
|
*
|
|
* @param minX
|
|
* the x coordinate of the minimum corner of the axis-aligned box
|
|
* @param minY
|
|
* the y coordinate of the minimum corner of the axis-aligned box
|
|
* @param minZ
|
|
* the z coordinate of the minimum corner of the axis-aligned box
|
|
* @param maxX
|
|
* the x coordinate of the maximum corner of the axis-aligned box
|
|
* @param maxY
|
|
* the y coordinate of the maximum corner of the axis-aligned box
|
|
* @param maxZ
|
|
* the y coordinate of the maximum corner of the axis-aligned box
|
|
* @param outMin
|
|
* will hold the minimum corner of the resulting axis-aligned box
|
|
* @param outMax
|
|
* will hold the maximum corner of the resulting axis-aligned box
|
|
* @return this
|
|
*/
|
|
Matrix4d transformAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vector3d outMin, Vector3d outMax);
|
|
|
|
/**
|
|
* Transform the axis-aligned box given as the minimum corner <code>min</code> and maximum corner <code>max</code>
|
|
* by <code>this</code> {@link #isAffine() affine} matrix and compute the axis-aligned box of the result whose minimum corner is stored in <code>outMin</code>
|
|
* and maximum corner stored in <code>outMax</code>.
|
|
*
|
|
* @param min
|
|
* the minimum corner of the axis-aligned box
|
|
* @param max
|
|
* the maximum corner of the axis-aligned box
|
|
* @param outMin
|
|
* will hold the minimum corner of the resulting axis-aligned box
|
|
* @param outMax
|
|
* will hold the maximum corner of the resulting axis-aligned box
|
|
* @return this
|
|
*/
|
|
Matrix4d transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d outMax);
|
|
|
|
/**
|
|
* Linearly interpolate <code>this</code> and <code>other</code> using the given interpolation factor <code>t</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>t</code> is <code>0.0</code> then the result is <code>this</code>. If the interpolation factor is <code>1.0</code>
|
|
* then the result is <code>other</code>.
|
|
*
|
|
* @param other
|
|
* the other matrix
|
|
* @param t
|
|
* the interpolation factor between 0.0 and 1.0
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d lerp(Matrix4dc other, double t, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a model transformation to this matrix for a right-handed coordinate system,
|
|
* that aligns the local <code>+Z</code> axis with <code>direction</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix,
|
|
* then the new matrix will be <code>M * L</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * L * v</code>,
|
|
* the lookat transformation will be applied first!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>mulAffine(new Matrix4d().lookAt(new Vector3d(), new Vector3d(dir).negate(), up).invertAffine(), dest)</code>
|
|
*
|
|
* @see #rotateTowards(double, double, double, double, double, double, Matrix4d)
|
|
*
|
|
* @param direction
|
|
* the direction to rotate towards
|
|
* @param up
|
|
* the up vector
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateTowards(Vector3dc direction, Vector3dc up, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a model transformation to this matrix for a right-handed coordinate system,
|
|
* that aligns the local <code>+Z</code> axis with <code>dir</code>
|
|
* and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix,
|
|
* then the new matrix will be <code>M * L</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * L * v</code>,
|
|
* the lookat transformation will be applied first!
|
|
* <p>
|
|
* This method is equivalent to calling: <code>mulAffine(new Matrix4d().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invertAffine(), dest)</code>
|
|
*
|
|
* @see #rotateTowards(Vector3dc, Vector3dc, Matrix4d)
|
|
*
|
|
* @param dirX
|
|
* the x-coordinate of the direction to rotate towards
|
|
* @param dirY
|
|
* the y-coordinate of the direction to rotate towards
|
|
* @param dirZ
|
|
* the z-coordinate of the direction to rotate towards
|
|
* @param upX
|
|
* the x-coordinate of the up vector
|
|
* @param upY
|
|
* the y-coordinate of the up vector
|
|
* @param upZ
|
|
* the z-coordinate of the up vector
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4d dest);
|
|
|
|
/**
|
|
* Extract the Euler angles from the rotation represented by the upper left 3x3 submatrix of <code>this</code>
|
|
* and store the extracted Euler angles in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes that the upper left of <code>this</code> only represents a rotation without scaling.
|
|
* <p>
|
|
* The Euler angles are always returned as the angle around X in the {@link Vector3d#x} field, the angle around Y in the {@link Vector3d#y}
|
|
* field and the angle around Z in the {@link Vector3d#z} field of the supplied {@link Vector3d} instance.
|
|
* <p>
|
|
* Note that the returned Euler angles must be applied in the order <code>X * Y * Z</code> to obtain the identical matrix.
|
|
* This means that calling {@link Matrix4dc#rotateXYZ(double, double, double, Matrix4d)} 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
|
|
* <code>m2</code> should be identical to <code>m</code> (disregarding possible floating-point inaccuracies).
|
|
* <pre>
|
|
* Matrix4d m = ...; // <- matrix only representing rotation
|
|
* Matrix4d n = new Matrix4d();
|
|
* n.rotateXYZ(m.getEulerAnglesXYZ(new Vector3d()));
|
|
* </pre>
|
|
* <p>
|
|
* Reference: <a href="https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix">http://en.wikipedia.org/</a>
|
|
*
|
|
* @param dest
|
|
* will hold the extracted Euler angles
|
|
* @return dest
|
|
*/
|
|
Vector3d getEulerAnglesXYZ(Vector3d dest);
|
|
|
|
/**
|
|
* Extract the Euler angles from the rotation represented by the upper left 3x3 submatrix of <code>this</code>
|
|
* and store the extracted Euler angles in <code>dest</code>.
|
|
* <p>
|
|
* This method assumes that the upper left of <code>this</code> only represents a rotation without scaling.
|
|
* <p>
|
|
* Note that the returned Euler angles must be applied in the order <code>Z * Y * X</code> to obtain the identical matrix.
|
|
* This means that calling {@link Matrix4dc#rotateZYX(double, double, double, Matrix4d)} 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
|
|
* <code>m2</code> should be identical to <code>m</code> (disregarding possible floating-point inaccuracies).
|
|
* <pre>
|
|
* Matrix4d m = ...; // <- matrix only representing rotation
|
|
* Matrix4d n = new Matrix4d();
|
|
* n.rotateZYX(m.getEulerAnglesZYX(new Vector3d()));
|
|
* </pre>
|
|
* <p>
|
|
* Reference: <a href="http://nghiaho.com/?page_id=846">http://nghiaho.com/</a>
|
|
*
|
|
* @param dest
|
|
* will hold the extracted Euler angles
|
|
* @return dest
|
|
*/
|
|
Vector3d getEulerAnglesZYX(Vector3d dest);
|
|
|
|
/**
|
|
* Test whether the given point <code>(x, y, z)</code> is within the frustum defined by <code>this</code> matrix.
|
|
* <p>
|
|
* This method assumes <code>this</code> matrix to be a transformation from any arbitrary coordinate system/space <code>M</code>
|
|
* into standard OpenGL clip space and tests whether the given point with the coordinates <code>(x, y, z)</code> given
|
|
* in space <code>M</code> is within the clip space.
|
|
* <p>
|
|
* When testing multiple points using the same transformation matrix, {@link FrustumIntersection} should be used instead.
|
|
* <p>
|
|
* Reference: <a href="http://gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdf">
|
|
* Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix</a>
|
|
*
|
|
* @param x
|
|
* the x-coordinate of the point
|
|
* @param y
|
|
* the y-coordinate of the point
|
|
* @param z
|
|
* the z-coordinate of the point
|
|
* @return <code>true</code> if the given point is inside the frustum; <code>false</code> otherwise
|
|
*/
|
|
boolean testPoint(double x, double y, double z);
|
|
|
|
/**
|
|
* Test whether the given sphere is partly or completely within or outside of the frustum defined by <code>this</code> matrix.
|
|
* <p>
|
|
* This method assumes <code>this</code> matrix to be a transformation from any arbitrary coordinate system/space <code>M</code>
|
|
* into standard OpenGL clip space and tests whether the given sphere with the coordinates <code>(x, y, z)</code> given
|
|
* in space <code>M</code> is within the clip space.
|
|
* <p>
|
|
* When testing multiple spheres using the same transformation matrix, or more sophisticated/optimized intersection algorithms are required,
|
|
* {@link FrustumIntersection} should be used instead.
|
|
* <p>
|
|
* The algorithm implemented by this method is conservative. This means that in certain circumstances a <i>false positive</i>
|
|
* can occur, when the method returns <code>true</code> for spheres that are actually not visible.
|
|
* See <a href="http://iquilezles.org/www/articles/frustumcorrect/frustumcorrect.htm">iquilezles.org</a> for an examination of this problem.
|
|
* <p>
|
|
* Reference: <a href="http://gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdf">
|
|
* Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix</a>
|
|
*
|
|
* @param x
|
|
* the x-coordinate of the sphere's center
|
|
* @param y
|
|
* the y-coordinate of the sphere's center
|
|
* @param z
|
|
* the z-coordinate of the sphere's center
|
|
* @param r
|
|
* the sphere's radius
|
|
* @return <code>true</code> if the given sphere is partly or completely inside the frustum; <code>false</code> otherwise
|
|
*/
|
|
boolean testSphere(double x, double y, double z, double r);
|
|
|
|
/**
|
|
* Test whether the given axis-aligned box is partly or completely within or outside of the frustum defined by <code>this</code> matrix.
|
|
* The box is specified via its min and max corner coordinates.
|
|
* <p>
|
|
* This method assumes <code>this</code> matrix to be a transformation from any arbitrary coordinate system/space <code>M</code>
|
|
* into standard OpenGL clip space and tests whether the given axis-aligned box with its minimum corner coordinates <code>(minX, minY, minZ)</code>
|
|
* and maximum corner coordinates <code>(maxX, maxY, maxZ)</code> given in space <code>M</code> is within the clip space.
|
|
* <p>
|
|
* When testing multiple axis-aligned boxes using the same transformation matrix, or more sophisticated/optimized intersection algorithms are required,
|
|
* {@link FrustumIntersection} should be used instead.
|
|
* <p>
|
|
* The algorithm implemented by this method is conservative. This means that in certain circumstances a <i>false positive</i>
|
|
* can occur, when the method returns <code>-1</code> for boxes that are actually not visible/do not intersect the frustum.
|
|
* See <a href="http://iquilezles.org/www/articles/frustumcorrect/frustumcorrect.htm">iquilezles.org</a> for an examination of this problem.
|
|
* <p>
|
|
* Reference: <a href="http://old.cescg.org/CESCG-2002/DSykoraJJelinek/">Efficient View Frustum Culling</a>
|
|
* <br>
|
|
* Reference: <a href="http://gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdf">
|
|
* Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix</a>
|
|
*
|
|
* @param minX
|
|
* the x-coordinate of the minimum corner
|
|
* @param minY
|
|
* the y-coordinate of the minimum corner
|
|
* @param minZ
|
|
* the z-coordinate of the minimum corner
|
|
* @param maxX
|
|
* the x-coordinate of the maximum corner
|
|
* @param maxY
|
|
* the y-coordinate of the maximum corner
|
|
* @param maxZ
|
|
* the z-coordinate of the maximum corner
|
|
* @return <code>true</code> if the axis-aligned box is completely or partly inside of the frustum; <code>false</code> otherwise
|
|
*/
|
|
boolean testAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ);
|
|
|
|
/**
|
|
* Apply an oblique projection transformation to this matrix with the given values for <code>a</code> and
|
|
* <code>b</code> and store the result in <code>dest</code>.
|
|
* <p>
|
|
* If <code>M</code> is <code>this</code> matrix and <code>O</code> the oblique transformation matrix,
|
|
* then the new matrix will be <code>M * O</code>. So when transforming a
|
|
* vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the
|
|
* oblique transformation will be applied first!
|
|
* <p>
|
|
* The oblique transformation is defined as:
|
|
* <pre>
|
|
* x' = x + a*z
|
|
* y' = y + a*z
|
|
* z' = z
|
|
* </pre>
|
|
* or in matrix form:
|
|
* <pre>
|
|
* 1 0 a 0
|
|
* 0 1 b 0
|
|
* 0 0 1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
*
|
|
* @param a
|
|
* the value for the z factor that applies to x
|
|
* @param b
|
|
* the value for the z factor that applies to y
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d obliqueZ(double a, double b, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a transformation to this matrix to ensure that the local Y axis (as obtained by {@link #positiveY(Vector3d)})
|
|
* will be coplanar to the plane spanned by the local Z axis (as obtained by {@link #positiveZ(Vector3d)}) and the
|
|
* given vector <code>up</code>, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This effectively ensures that the resulting matrix will be equal to the one obtained from calling
|
|
* {@link Matrix4d#setLookAt(Vector3dc, Vector3dc, Vector3dc)} with the current
|
|
* local origin of this matrix (as obtained by {@link #originAffine(Vector3d)}), the sum of this position and the
|
|
* negated local Z axis as well as the given vector <code>up</code>.
|
|
* <p>
|
|
* This method must only be called on {@link #isAffine()} matrices.
|
|
*
|
|
* @param up
|
|
* the up vector
|
|
* @param dest
|
|
* will hold the result
|
|
* @return this
|
|
*/
|
|
Matrix4d withLookAtUp(Vector3dc up, Matrix4d dest);
|
|
|
|
/**
|
|
* Apply a transformation to this matrix to ensure that the local Y axis (as obtained by {@link #positiveY(Vector3d)})
|
|
* will be coplanar to the plane spanned by the local Z axis (as obtained by {@link #positiveZ(Vector3d)}) and the
|
|
* given vector <code>(upX, upY, upZ)</code>, and store the result in <code>dest</code>.
|
|
* <p>
|
|
* This effectively ensures that the resulting matrix will be equal to the one obtained from calling
|
|
* {@link Matrix4d#setLookAt(double, double, double, double, double, double, double, double, double)} called with the current
|
|
* local origin of this matrix (as obtained by {@link #originAffine(Vector3d)}), the sum of this position and the
|
|
* negated local Z axis as well as the given vector <code>(upX, upY, upZ)</code>.
|
|
* <p>
|
|
* This method must only be called on {@link #isAffine()} matrices.
|
|
*
|
|
* @param upX
|
|
* the x coordinate of the up vector
|
|
* @param upY
|
|
* the y coordinate of the up vector
|
|
* @param upZ
|
|
* the z coordinate of the up vector
|
|
* @param dest
|
|
* will hold the result
|
|
* @return this
|
|
*/
|
|
Matrix4d withLookAtUp(double upX, double upY, double upZ, Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 1 0 0 0
|
|
* 0 0 1 0
|
|
* 0 1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapXZY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 1 0 0 0
|
|
* 0 0 -1 0
|
|
* 0 1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapXZnY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 1 0 0 0
|
|
* 0 -1 0 0
|
|
* 0 0 -1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapXnYnZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 1 0 0 0
|
|
* 0 0 1 0
|
|
* 0 -1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapXnZY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 1 0 0 0
|
|
* 0 0 -1 0
|
|
* 0 -1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapXnZnY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 1 0 0
|
|
* 1 0 0 0
|
|
* 0 0 1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapYXZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 1 0 0
|
|
* 1 0 0 0
|
|
* 0 0 -1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapYXnZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 1 0
|
|
* 1 0 0 0
|
|
* 0 1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapYZX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 -1 0
|
|
* 1 0 0 0
|
|
* 0 1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapYZnX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 -1 0 0
|
|
* 1 0 0 0
|
|
* 0 0 1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapYnXZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 -1 0 0
|
|
* 1 0 0 0
|
|
* 0 0 -1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapYnXnZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 1 0
|
|
* 1 0 0 0
|
|
* 0 -1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapYnZX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 -1 0
|
|
* 1 0 0 0
|
|
* 0 -1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapYnZnX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 1 0 0
|
|
* 0 0 1 0
|
|
* 1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapZXY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 1 0 0
|
|
* 0 0 -1 0
|
|
* 1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapZXnY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 1 0
|
|
* 0 1 0 0
|
|
* 1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapZYX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 -1 0
|
|
* 0 1 0 0
|
|
* 1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapZYnX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 -1 0 0
|
|
* 0 0 1 0
|
|
* 1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapZnXY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 -1 0 0
|
|
* 0 0 -1 0
|
|
* 1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapZnXnY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 1 0
|
|
* 0 -1 0 0
|
|
* 1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapZnYX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 -1 0
|
|
* 0 -1 0 0
|
|
* 1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapZnYnX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* -1 0 0 0
|
|
* 0 1 0 0
|
|
* 0 0 -1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnXYnZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* -1 0 0 0
|
|
* 0 0 1 0
|
|
* 0 1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnXZY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* -1 0 0 0
|
|
* 0 0 -1 0
|
|
* 0 1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnXZnY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* -1 0 0 0
|
|
* 0 -1 0 0
|
|
* 0 0 1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnXnYZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* -1 0 0 0
|
|
* 0 -1 0 0
|
|
* 0 0 -1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnXnYnZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* -1 0 0 0
|
|
* 0 0 1 0
|
|
* 0 -1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnXnZY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* -1 0 0 0
|
|
* 0 0 -1 0
|
|
* 0 -1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnXnZnY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 1 0 0
|
|
* -1 0 0 0
|
|
* 0 0 1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnYXZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 1 0 0
|
|
* -1 0 0 0
|
|
* 0 0 -1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnYXnZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 1 0
|
|
* -1 0 0 0
|
|
* 0 1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnYZX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 -1 0
|
|
* -1 0 0 0
|
|
* 0 1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnYZnX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 -1 0 0
|
|
* -1 0 0 0
|
|
* 0 0 1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnYnXZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 -1 0 0
|
|
* -1 0 0 0
|
|
* 0 0 -1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnYnXnZ(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 1 0
|
|
* -1 0 0 0
|
|
* 0 -1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnYnZX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 -1 0
|
|
* -1 0 0 0
|
|
* 0 -1 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnYnZnX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 1 0 0
|
|
* 0 0 1 0
|
|
* -1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnZXY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 1 0 0
|
|
* 0 0 -1 0
|
|
* -1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnZXnY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 1 0
|
|
* 0 1 0 0
|
|
* -1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnZYX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 -1 0
|
|
* 0 1 0 0
|
|
* -1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnZYnX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 -1 0 0
|
|
* 0 0 1 0
|
|
* -1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnZnXY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 -1 0 0
|
|
* 0 0 -1 0
|
|
* -1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnZnXnY(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 1 0
|
|
* 0 -1 0 0
|
|
* -1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnZnYX(Matrix4d dest);
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 0 0 -1 0
|
|
* 0 -1 0 0
|
|
* -1 0 0 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d mapnZnYnX(Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* -1 0 0 0
|
|
* 0 1 0 0
|
|
* 0 0 1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d negateX(Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 1 0 0 0
|
|
* 0 -1 0 0
|
|
* 0 0 1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d negateY(Matrix4d dest);
|
|
|
|
/**
|
|
* Multiply <code>this</code> by the matrix
|
|
* <pre>
|
|
* 1 0 0 0
|
|
* 0 1 0 0
|
|
* 0 0 -1 0
|
|
* 0 0 0 1
|
|
* </pre>
|
|
* and store the result in <code>dest</code>.
|
|
*
|
|
* @param dest
|
|
* will hold the result
|
|
* @return dest
|
|
*/
|
|
Matrix4d negateZ(Matrix4d dest);
|
|
|
|
/**
|
|
* Compare the matrix elements of <code>this</code> matrix with the given matrix using the given <code>delta</code>
|
|
* and return whether all of them are equal within a maximum difference of <code>delta</code>.
|
|
* <p>
|
|
* Please note that this method is not used by any data structure such as {@link ArrayList} {@link HashSet} or {@link HashMap}
|
|
* and their operations, such as {@link ArrayList#contains(Object)} or {@link HashSet#remove(Object)}, since those
|
|
* data structures only use the {@link Object#equals(Object)} and {@link Object#hashCode()} methods.
|
|
*
|
|
* @param m
|
|
* the other matrix
|
|
* @param delta
|
|
* the allowed maximum difference
|
|
* @return <code>true</code> whether all of the matrix elements are equal; <code>false</code> otherwise
|
|
*/
|
|
boolean equals(Matrix4dc m, double delta);
|
|
|
|
/**
|
|
* Determine whether all matrix elements are finite floating-point values, that
|
|
* is, they are not {@link Double#isNaN() NaN} and not
|
|
* {@link Double#isInfinite() infinity}.
|
|
*
|
|
* @return {@code true} if all components are finite floating-point values;
|
|
* {@code false} otherwise
|
|
*/
|
|
boolean isFinite();
|
|
|
|
}
|