Uses of Class org.joml.Vector3d (JOML 1.10.5 API)

Packages that use Vector3d
Package Description

org.joml
Contains all classes of JOML.

Packages that use Vector3d
Package	Description
org.joml	Contains all classes of JOML.

Uses of Vector3d in org.joml

Methods in org.joml that return Vector3d
Modifier and Type	Method	Description
`Vector3d`	Vector3d.`absolute()`	Set `this` vector's components to their respective absolute values.
`Vector3d`	Vector3d.`absolute(Vector3d dest)`
`Vector3d`	Vector3dc.`absolute(Vector3d dest)`	Compute the absolute values of the individual components of `this` and store the result in `dest`.
`Vector3d`	Vector3d.`add(double x, double y, double z)`	Increment the components of this vector by the given values.
`Vector3d`	Vector3d.`add(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`add(Vector3dc v)`	Add the supplied vector to this one.
`Vector3d`	Vector3d.`add(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3d.`add(Vector3fc v)`	Add the supplied vector to this one.
`Vector3d`	Vector3d.`add(Vector3fc v, Vector3d dest)`
`Vector3d`	Vector3dc.`add(double x, double y, double z, Vector3d dest)`	Increment the components of this vector by the given values and store the result in `dest`.
`Vector3d`	Vector3dc.`add(Vector3dc v, Vector3d dest)`	Add the supplied vector to this one and store the result in `dest`.
`Vector3d`	Vector3dc.`add(Vector3fc v, Vector3d dest)`	Add the supplied vector to this one and store the result in `dest`.
`Vector3d`	Vector3d.`ceil()`	Set each component of this vector to the smallest (closest to negative infinity) `double` value that is greater than or equal to that component and is equal to a mathematical integer.
`Vector3d`	Vector3d.`ceil(Vector3d dest)`
`Vector3d`	Vector3dc.`ceil(Vector3d dest)`	Compute for each component of this vector the smallest (closest to negative infinity) `double` value that is greater than or equal to that component and is equal to a mathematical integer and store the result in `dest`.
`Vector3d`	Vector3d.`cross(double x, double y, double z)`	Set this vector to be the cross product of itself and `(x, y, z)`.
`Vector3d`	Vector3d.`cross(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`cross(Vector3dc v)`	Set this vector to be the cross product of this and v2.
`Vector3d`	Vector3d.`cross(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3dc.`cross(double x, double y, double z, Vector3d dest)`	Compute the cross product of this vector and `(x, y, z)` and store the result in `dest`.
`Vector3d`	Vector3dc.`cross(Vector3dc v, Vector3d dest)`	Calculate the cross product of this and v2 and store the result in `dest`.
`Vector3d`	Vector3d.`div(double scalar)`	Divide this Vector3d by the given scalar value.
`Vector3d`	Vector3d.`div(double x, double y, double z)`	Divide the components of this Vector3d by the given scalar values and store the result in `this`.
`Vector3d`	Vector3d.`div(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`div(double scalar, Vector3d dest)`
`Vector3d`	Vector3d.`div(Vector3d v)`	Divide this Vector3d component-wise by another Vector3dc.
`Vector3d`	Vector3d.`div(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3d.`div(Vector3fc v)`	Divide this Vector3d component-wise by another Vector3fc.
`Vector3d`	Vector3d.`div(Vector3fc v, Vector3d dest)`
`Vector3d`	Vector3dc.`div(double x, double y, double z, Vector3d dest)`	Divide the components of this Vector3f by the given scalar values and store the result in `dest`.
`Vector3d`	Vector3dc.`div(double scalar, Vector3d dest)`	Divide this Vector3d by the given scalar value and store the result in `dest`.
`Vector3d`	Vector3dc.`div(Vector3dc v, Vector3d dest)`	Divide this by `v` component-wise and store the result into `dest`.
`Vector3d`	Vector3dc.`div(Vector3fc v, Vector3d dest)`	Divide this Vector3d component-wise by another Vector3f and store the result in `dest`.
`static Vector3d`	Intersectiond.`findClosestPointOnLineSegment(double aX, double aY, double aZ, double bX, double bY, double bZ, double pX, double pY, double pZ, Vector3d result)`	Find the point on the given line segment which is closest to the specified point `(pX, pY, pZ)`, and store the result in `result`.
`static Vector3d`	Intersectiond.`findClosestPointOnPlane(double aX, double aY, double aZ, double nX, double nY, double nZ, double pX, double pY, double pZ, Vector3d result)`	Find the point on the given plane which is closest to the specified point `(pX, pY, pZ)` and store the result in `result`.
`static Vector3d`	Intersectiond.`findClosestPointOnRectangle(double aX, double aY, double aZ, double bX, double bY, double bZ, double cX, double cY, double cZ, double pX, double pY, double pZ, Vector3d res)`	Find the point on a given rectangle, specified via three of its corners, which is closest to the specified point `(pX, pY, pZ)` and store the result into `res`.
`Vector3d`	Vector3d.`floor()`	Set each component of this vector to the largest (closest to positive infinity) `double` value that is less than or equal to that component and is equal to a mathematical integer.
`Vector3d`	Vector3d.`floor(Vector3d dest)`
`Vector3d`	Vector3dc.`floor(Vector3d dest)`	Compute for each component of this vector the largest (closest to positive infinity) `double` value that is less than or equal to that component and is equal to a mathematical integer and store the result in `dest`.
`Vector3d`	Vector3d.`fma(double a, Vector3dc b)`	Add the component-wise multiplication of `a * b` to this vector.
`Vector3d`	Vector3d.`fma(double a, Vector3dc b, Vector3d dest)`
`Vector3d`	Vector3d.`fma(double a, Vector3fc b)`	Add the component-wise multiplication of `a * b` to this vector.
`Vector3d`	Vector3d.`fma(double a, Vector3fc b, Vector3d dest)`
`Vector3d`	Vector3d.`fma(Vector3dc a, Vector3dc b)`	Add the component-wise multiplication of `a * b` to this vector.
`Vector3d`	Vector3d.`fma(Vector3dc a, Vector3dc b, Vector3d dest)`
`Vector3d`	Vector3d.`fma(Vector3dc a, Vector3fc b, Vector3d dest)`
`Vector3d`	Vector3d.`fma(Vector3fc a, Vector3fc b)`	Add the component-wise multiplication of `a * b` to this vector.
`Vector3d`	Vector3d.`fma(Vector3fc a, Vector3fc b, Vector3d dest)`
`Vector3d`	Vector3dc.`fma(double a, Vector3dc b, Vector3d dest)`	Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector3d`	Vector3dc.`fma(double a, Vector3fc b, Vector3d dest)`	Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector3d`	Vector3dc.`fma(Vector3dc a, Vector3dc b, Vector3d dest)`	Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector3d`	Vector3dc.`fma(Vector3dc a, Vector3fc b, Vector3d dest)`	Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector3d`	Vector3dc.`fma(Vector3fc a, Vector3fc b, Vector3d dest)`	Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector3d`	Matrix4d.`frustumCorner(int corner, Vector3d dest)`
`Vector3d`	Matrix4dc.`frustumCorner(int corner, Vector3d point)`	Compute the corner coordinates of the frustum defined by `this` matrix, which can be a projection matrix or a combined modelview-projection matrix, and store the result in the given `point`.
`Vector3d`	Matrix4d.`frustumRayDir(double x, double y, Vector3d dest)`
`Vector3d`	Matrix4dc.`frustumRayDir(double x, double y, Vector3d dir)`	Obtain the direction of a ray starting at the center of the coordinate system and going through the near frustum plane.
`Vector3d`	Vector3d.`get(Vector3d dest)`
`Vector3d`	Vector3dc.`get(Vector3d dest)`	Set the components of the given vector `dest` to those of `this` vector.
`Vector3d`	Vector3f.`get(Vector3d dest)`
`Vector3d`	Vector3fc.`get(Vector3d dest)`	Set the components of the given vector `dest` to those of `this` vector.
`Vector3d`	Matrix3d.`getColumn(int column, Vector3d dest)`
`Vector3d`	Matrix3dc.`getColumn(int column, Vector3d dest)`	Get the column at the given `column` index, starting with `0`.
`Vector3d`	Matrix4d.`getColumn(int column, Vector3d dest)`
`Vector3d`	Matrix4dc.`getColumn(int column, Vector3d dest)`	Get the first three components of the column at the given `column` index, starting with `0`.
`Vector3d`	Matrix4x3d.`getColumn(int column, Vector3d dest)`
`Vector3d`	Matrix4x3dc.`getColumn(int column, Vector3d dest)`	Get the column at the given `column` index, starting with `0`.
`Vector3d`	Matrix3d.`getEulerAnglesXYZ(Vector3d dest)`
`Vector3d`	Matrix3dc.`getEulerAnglesXYZ(Vector3d dest)`	Extract the Euler angles from the rotation represented by `this` matrix and store the extracted Euler angles in `dest`.
`Vector3d`	Matrix4d.`getEulerAnglesXYZ(Vector3d dest)`
`Vector3d`	Matrix4dc.`getEulerAnglesXYZ(Vector3d dest)`	Extract the Euler angles from the rotation represented by the upper left 3x3 submatrix of `this` and store the extracted Euler angles in `dest`.
`Vector3d`	Matrix4x3d.`getEulerAnglesXYZ(Vector3d dest)`
`Vector3d`	Matrix4x3dc.`getEulerAnglesXYZ(Vector3d dest)`	Extract the Euler angles from the rotation represented by the left 3x3 submatrix of `this` and store the extracted Euler angles in `dest`.
`Vector3d`	Quaterniond.`getEulerAnglesXYZ(Vector3d eulerAngles)`
`Vector3d`	Quaterniondc.`getEulerAnglesXYZ(Vector3d eulerAngles)`	Get the euler angles in radians in rotation sequence `XYZ` of this quaternion and store them in the provided parameter `eulerAngles`.
`Vector3d`	Quaterniond.`getEulerAnglesYXZ(Vector3d eulerAngles)`
`Vector3d`	Quaterniondc.`getEulerAnglesYXZ(Vector3d eulerAngles)`	Get the euler angles in radians in rotation sequence `YXZ` of this quaternion and store them in the provided parameter `eulerAngles`.
`Vector3d`	Quaterniond.`getEulerAnglesZXY(Vector3d eulerAngles)`
`Vector3d`	Quaterniondc.`getEulerAnglesZXY(Vector3d eulerAngles)`	Get the euler angles in radians in rotation sequence `ZXY` of this quaternion and store them in the provided parameter `eulerAngles`.
`Vector3d`	Matrix3d.`getEulerAnglesZYX(Vector3d dest)`
`Vector3d`	Matrix3dc.`getEulerAnglesZYX(Vector3d dest)`	Extract the Euler angles from the rotation represented by `this` matrix and store the extracted Euler angles in `dest`.
`Vector3d`	Matrix4d.`getEulerAnglesZYX(Vector3d dest)`
`Vector3d`	Matrix4dc.`getEulerAnglesZYX(Vector3d dest)`	Extract the Euler angles from the rotation represented by the upper left 3x3 submatrix of `this` and store the extracted Euler angles in `dest`.
`Vector3d`	Matrix4x3d.`getEulerAnglesZYX(Vector3d dest)`
`Vector3d`	Matrix4x3dc.`getEulerAnglesZYX(Vector3d dest)`	Extract the Euler angles from the rotation represented by the left 3x3 submatrix of `this` and store the extracted Euler angles in `dest`.
`Vector3d`	Quaterniond.`getEulerAnglesZYX(Vector3d eulerAngles)`
`Vector3d`	Quaterniondc.`getEulerAnglesZYX(Vector3d eulerAngles)`	Get the euler angles in radians in rotation sequence `ZYX` of this quaternion and store them in the provided parameter `eulerAngles`.
`Vector3d`	Matrix3d.`getRow(int row, Vector3d dest)`
`Vector3d`	Matrix3dc.`getRow(int row, Vector3d dest)`	Get the row at the given `row` index, starting with `0`.
`Vector3d`	Matrix4d.`getRow(int row, Vector3d dest)`
`Vector3d`	Matrix4dc.`getRow(int row, Vector3d dest)`	Get the first three components of the row at the given `row` index, starting with `0`.
`Vector3d`	Matrix3d.`getScale(Vector3d dest)`
`Vector3d`	Matrix3dc.`getScale(Vector3d dest)`	Get the scaling factors of `this` matrix for the three base axes.
`Vector3d`	Matrix4d.`getScale(Vector3d dest)`
`Vector3d`	Matrix4dc.`getScale(Vector3d dest)`	Get the scaling factors of `this` matrix for the three base axes.
`Vector3d`	Matrix4x3d.`getScale(Vector3d dest)`
`Vector3d`	Matrix4x3dc.`getScale(Vector3d dest)`	Get the scaling factors of `this` matrix for the three base axes.
`Vector3d`	Matrix4d.`getTranslation(Vector3d dest)`
`Vector3d`	Matrix4dc.`getTranslation(Vector3d dest)`	Get only the translation components `(m30, m31, m32)` of this matrix and store them in the given vector `xyz`.
`Vector3d`	Matrix4x3d.`getTranslation(Vector3d dest)`
`Vector3d`	Matrix4x3dc.`getTranslation(Vector3d dest)`	Get only the translation components `(m30, m31, m32)` of this matrix and store them in the given vector `xyz`.
`Vector3d`	Vector3d.`half(double x, double y, double z)`	Compute the half vector between this and the vector `(x, y, z)`.
`Vector3d`	Vector3d.`half(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`half(Vector3dc other)`	Compute the half vector between this and the other vector.
`Vector3d`	Vector3d.`half(Vector3dc other, Vector3d dest)`
`Vector3d`	Vector3dc.`half(double x, double y, double z, Vector3d dest)`	Compute the half vector between this and the vector `(x, y, z)` and store the result in `dest`.
`Vector3d`	Vector3dc.`half(Vector3dc other, Vector3d dest)`	Compute the half vector between this and the other vector and store the result in `dest`.
`Vector3d`	Vector3d.`hermite(Vector3dc t0, Vector3dc v1, Vector3dc t1, double t, Vector3d dest)`
`Vector3d`	Vector3dc.`hermite(Vector3dc t0, Vector3dc v1, Vector3dc t1, double t, Vector3d dest)`	Compute a hermite interpolation between `this` vector and its associated tangent `t0` and the given vector `v` with its tangent `t1` and store the result in `dest`.
`static Vector3d`	Interpolationd.`interpolateTriangle(double v0X, double v0Y, double f0X, double f0Y, double f0Z, double v1X, double v1Y, double f1X, double f1Y, double f1Z, double v2X, double v2Y, double f2X, double f2Y, double f2Z, double x, double y, Vector3d dest)`	Bilinearly interpolate the three-dimensional vector f over the given triangle and store the result in `dest`.
`static Vector3d`	Interpolationd.`interpolationFactorsTriangle(double v0X, double v0Y, double v1X, double v1Y, double v2X, double v2Y, double x, double y, Vector3d dest)`	Compute the interpolation factors `(t0, t1, t2)` in order to interpolate an arbitrary value over a given triangle at the given point `(x, y)`.
`Vector3d`	Vector3d.`lerp(Vector3dc other, double t)`	Linearly interpolate `this` and `other` using the given interpolation factor `t` and store the result in `this`.
`Vector3d`	Vector3d.`lerp(Vector3dc other, double t, Vector3d dest)`
`Vector3d`	Vector3dc.`lerp(Vector3dc other, double t, Vector3d dest)`	Linearly interpolate `this` and `other` using the given interpolation factor `t` and store the result in `dest`.
`Vector3d`	Vector3d.`max(Vector3dc v)`	Set the components of this vector to be the component-wise maximum of this and the other vector.
`Vector3d`	Vector3d.`max(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3dc.`max(Vector3dc v, Vector3d dest)`	Set the components of `dest` to be the component-wise maximum of this and the other vector.
`Vector3d`	Vector3d.`min(Vector3dc v)`	Set the components of this vector to be the component-wise minimum of this and the other vector.
`Vector3d`	Vector3d.`min(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3dc.`min(Vector3dc v, Vector3d dest)`	Set the components of `dest` to be the component-wise minimum of this and the other vector.
`Vector3d`	Vector3d.`mul(double scalar)`	Multiply this Vector3d by the given scalar value.
`Vector3d`	Vector3d.`mul(double x, double y, double z)`	Multiply the components of this Vector3d by the given scalar values and store the result in `this`.
`Vector3d`	Vector3d.`mul(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`mul(double scalar, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Matrix3dc mat)`	Multiply the given matrix `mat` with this Vector3d.
`Vector3d`	Vector3d.`mul(Matrix3dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Matrix3fc mat)`	Multiply the given matrix `mat` with this Vector3d.
`Vector3d`	Vector3d.`mul(Matrix3fc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Matrix3x2dc mat)`	Multiply the given matrix with this Vector3d by assuming a third row in the matrix of `(0, 0, 1)` and store the result in `this`.
`Vector3d`	Vector3d.`mul(Matrix3x2dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Matrix3x2fc mat)`	Multiply the given matrix with this Vector3d by assuming a third row in the matrix of `(0, 0, 1)` and store the result in `this`.
`Vector3d`	Vector3d.`mul(Matrix3x2fc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Vector3dc v)`	Multiply this Vector3d component-wise by another Vector3dc.
`Vector3d`	Vector3d.`mul(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Vector3fc v)`	Multiply this Vector3d component-wise by another Vector3fc.
`Vector3d`	Vector3d.`mul(Vector3fc v, Vector3d dest)`
`Vector3d`	Vector3dc.`mul(double x, double y, double z, Vector3d dest)`	Multiply the components of this Vector3f by the given scalar values and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(double scalar, Vector3d dest)`	Multiply this Vector3d by the given scalar value and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(Matrix3dc mat, Vector3d dest)`	Multiply the given matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(Matrix3fc mat, Vector3d dest)`	Multiply the given matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(Matrix3x2dc mat, Vector3d dest)`	Multiply the given matrix `mat` with `this` by assuming a third row in the matrix of `(0, 0, 1)` and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(Matrix3x2fc mat, Vector3d dest)`	Multiply the given matrix `mat` with `this` by assuming a third row in the matrix of `(0, 0, 1)` and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(Vector3dc v, Vector3d dest)`	Multiply this by `v` component-wise and store the result into `dest`.
`Vector3d`	Vector3dc.`mul(Vector3fc v, Vector3d dest)`	Multiply this Vector3d component-wise by another Vector3f and store the result in `dest`.
`Vector3d`	Vector3d.`mulAdd(double a, Vector3dc b)`	Add the component-wise multiplication of `this * a` to `b` and store the result in `this`.
`Vector3d`	Vector3d.`mulAdd(double a, Vector3dc b, Vector3d dest)`
`Vector3d`	Vector3d.`mulAdd(Vector3dc a, Vector3dc b)`	Add the component-wise multiplication of `this * a` to `b` and store the result in `this`.
`Vector3d`	Vector3d.`mulAdd(Vector3dc a, Vector3dc b, Vector3d dest)`
`Vector3d`	Vector3d.`mulAdd(Vector3fc a, Vector3dc b, Vector3d dest)`
`Vector3d`	Vector3dc.`mulAdd(double a, Vector3dc b, Vector3d dest)`	Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulAdd(Vector3dc a, Vector3dc b, Vector3d dest)`	Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulAdd(Vector3fc a, Vector3dc b, Vector3d dest)`	Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
`Vector3d`	Vector3d.`mulDirection(Matrix4dc mat)`	Multiply the given 4x4 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulDirection(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulDirection(Matrix4fc mat)`	Multiply the given 4x4 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulDirection(Matrix4fc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulDirection(Matrix4x3dc mat)`	Multiply the given 4x3 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulDirection(Matrix4x3dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulDirection(Matrix4x3fc mat)`	Multiply the given 4x3 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulDirection(Matrix4x3fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulDirection(Matrix4dc mat, Vector3d dest)`	Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulDirection(Matrix4fc mat, Vector3d dest)`	Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulDirection(Matrix4x3dc mat, Vector3d dest)`	Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulDirection(Matrix4x3fc mat, Vector3d dest)`	Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3d.`mulPosition(Matrix4dc mat)`	Multiply the given 4x4 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulPosition(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulPosition(Matrix4fc mat)`	Multiply the given 4x4 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulPosition(Matrix4fc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulPosition(Matrix4x3dc mat)`	Multiply the given 4x3 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulPosition(Matrix4x3dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulPosition(Matrix4x3fc mat)`	Multiply the given 4x3 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulPosition(Matrix4x3fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulPosition(Matrix4dc mat, Vector3d dest)`	Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulPosition(Matrix4fc mat, Vector3d dest)`	Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulPosition(Matrix4x3dc mat, Vector3d dest)`	Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulPosition(Matrix4x3fc mat, Vector3d dest)`	Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3d.`mulProject(Matrix4dc mat)`	Multiply the given matrix `mat` this Vector3d, perform perspective division.
`Vector3d`	Vector3d.`mulProject(Matrix4dc mat, double w, Vector3d dest)`
`Vector3d`	Vector3d.`mulProject(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulProject(Matrix4fc mat)`	Multiply the given matrix `mat` with this Vector3d, perform perspective division.
`Vector3d`	Vector3d.`mulProject(Matrix4fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulProject(Matrix4dc mat, double w, Vector3d dest)`	Multiply the given matrix `mat` with this Vector3d, perform perspective division and store the result in `dest`.
`Vector3d`	Vector3dc.`mulProject(Matrix4dc mat, Vector3d dest)`	Multiply the given matrix `mat` with this Vector3d, perform perspective division and store the result in `dest`.
`Vector3d`	Vector3dc.`mulProject(Matrix4fc mat, Vector3d dest)`	Multiply the given matrix `mat` with this Vector3d, perform perspective division and store the result in `dest`.
`Vector3d`	Vector4d.`mulProject(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector4dc.`mulProject(Matrix4dc mat, Vector3d dest)`	Multiply the given matrix `mat` with this Vector4d, perform perspective division and store the `(x, y, z)` result in `dest`.
`Vector3d`	Vector3d.`mulTranspose(Matrix3dc mat)`	Multiply the transpose of the given matrix with this Vector3d and store the result in `this`.
`Vector3d`	Vector3d.`mulTranspose(Matrix3dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulTranspose(Matrix3fc mat)`	Multiply the transpose of the given matrix with this Vector3d and store the result in `this`.
`Vector3d`	Vector3d.`mulTranspose(Matrix3fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulTranspose(Matrix3dc mat, Vector3d dest)`	Multiply the transpose of the given matrix with this Vector3f and store the result in `dest`.
`Vector3d`	Vector3dc.`mulTranspose(Matrix3fc mat, Vector3d dest)`	Multiply the transpose of the given matrix with this Vector3f and store the result in `dest`.
`Vector3d`	Vector3d.`mulTransposeDirection(Matrix4dc mat)`	Multiply the transpose of the given 4x4 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulTransposeDirection(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulTransposeDirection(Matrix4fc mat)`	Multiply the transpose of the given 4x4 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulTransposeDirection(Matrix4fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulTransposeDirection(Matrix4dc mat, Vector3d dest)`	Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulTransposeDirection(Matrix4fc mat, Vector3d dest)`	Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3d.`mulTransposePosition(Matrix4dc mat)`	Multiply the transpose of the given 4x4 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulTransposePosition(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulTransposePosition(Matrix4fc mat)`	Multiply the transpose of the given 4x4 matrix `mat` with `this`.
`Vector3d`	Vector3d.`mulTransposePosition(Matrix4fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulTransposePosition(Matrix4dc mat, Vector3d dest)`	Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulTransposePosition(Matrix4fc mat, Vector3d dest)`	Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3d.`negate()`	Negate this vector.
`Vector3d`	Vector3d.`negate(Vector3d dest)`
`Vector3d`	Vector3dc.`negate(Vector3d dest)`	Negate this vector and store the result in `dest`.
`Vector3d`	Vector3d.`normalize()`	Normalize this vector.
`Vector3d`	Vector3d.`normalize(double length)`	Scale this vector to have the given length.
`Vector3d`	Vector3d.`normalize(double length, Vector3d dest)`
`Vector3d`	Vector3d.`normalize(Vector3d dest)`
`Vector3d`	Vector3dc.`normalize(double length, Vector3d dest)`	Scale this vector to have the given length and store the result in `dest`.
`Vector3d`	Vector3dc.`normalize(Vector3d dest)`	Normalize this vector and store the result in `dest`.
`Vector3d`	Matrix3d.`normalizedPositiveX(Vector3d dir)`
`Vector3d`	Matrix3dc.`normalizedPositiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4d.`normalizedPositiveX(Vector3d dir)`
`Vector3d`	Matrix4dc.`normalizedPositiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4x3d.`normalizedPositiveX(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`normalizedPositiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Quaterniond.`normalizedPositiveX(Vector3d dir)`
`Vector3d`	Quaterniondc.`normalizedPositiveX(Vector3d dir)`	Obtain the direction of `+X` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3d`	Matrix3d.`normalizedPositiveY(Vector3d dir)`
`Vector3d`	Matrix3dc.`normalizedPositiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4d.`normalizedPositiveY(Vector3d dir)`
`Vector3d`	Matrix4dc.`normalizedPositiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4x3d.`normalizedPositiveY(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`normalizedPositiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Quaterniond.`normalizedPositiveY(Vector3d dir)`
`Vector3d`	Quaterniondc.`normalizedPositiveY(Vector3d dir)`	Obtain the direction of `+Y` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3d`	Matrix3d.`normalizedPositiveZ(Vector3d dir)`
`Vector3d`	Matrix3dc.`normalizedPositiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4d.`normalizedPositiveZ(Vector3d dir)`
`Vector3d`	Matrix4dc.`normalizedPositiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4x3d.`normalizedPositiveZ(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`normalizedPositiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Quaterniond.`normalizedPositiveZ(Vector3d dir)`
`Vector3d`	Quaterniondc.`normalizedPositiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3d`	Matrix4d.`origin(Vector3d dest)`
`Vector3d`	Matrix4dc.`origin(Vector3d origin)`	Obtain the position that gets transformed to the origin by `this` matrix.
`Vector3d`	Matrix4x3d.`origin(Vector3d origin)`
`Vector3d`	Matrix4x3dc.`origin(Vector3d origin)`	Obtain the position that gets transformed to the origin by `this` matrix.
`Vector3d`	Matrix4d.`originAffine(Vector3d dest)`
`Vector3d`	Matrix4dc.`originAffine(Vector3d origin)`	Obtain the position that gets transformed to the origin by `this` `affine` matrix.
`Vector3d`	Vector3d.`orthogonalize(Vector3dc v)`	Transform `this` vector so that it is orthogonal to the given vector `v` and normalize the result.
`Vector3d`	Vector3d.`orthogonalize(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3dc.`orthogonalize(Vector3dc v, Vector3d dest)`	Transform `this` vector so that it is orthogonal to the given vector `v`, normalize the result and store it into `dest`.
`Vector3d`	Vector3d.`orthogonalizeUnit(Vector3dc v)`	Transform `this` vector so that it is orthogonal to the given unit vector `v` and normalize the result.
`Vector3d`	Vector3d.`orthogonalizeUnit(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3dc.`orthogonalizeUnit(Vector3dc v, Vector3d dest)`	Transform `this` vector so that it is orthogonal to the given unit vector `v`, normalize the result and store it into `dest`.
`Vector3d`	Matrix4d.`perspectiveInvOrigin(Vector3d dest)`
`Vector3d`	Matrix4dc.`perspectiveInvOrigin(Vector3d dest)`	Compute the eye/origin of the inverse of the perspective frustum transformation defined by `this` 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 `dest`.
`Vector3d`	Matrix4d.`perspectiveOrigin(Vector3d dest)`
`Vector3d`	Matrix4dc.`perspectiveOrigin(Vector3d origin)`	Compute the eye/origin of the perspective frustum transformation defined by `this` matrix, which can be a projection matrix or a combined modelview-projection matrix, and store the result in the given `origin`.
`Vector3d`	Matrix3d.`positiveX(Vector3d dir)`
`Vector3d`	Matrix3dc.`positiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4d.`positiveX(Vector3d dir)`
`Vector3d`	Matrix4dc.`positiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4x3d.`positiveX(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`positiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` matrix is applied.
`Vector3d`	Quaterniond.`positiveX(Vector3d dir)`
`Vector3d`	Quaterniondc.`positiveX(Vector3d dir)`	Obtain the direction of `+X` before the rotation transformation represented by `this` quaternion is applied.
`Vector3d`	Matrix3d.`positiveY(Vector3d dir)`
`Vector3d`	Matrix3dc.`positiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4d.`positiveY(Vector3d dir)`
`Vector3d`	Matrix4dc.`positiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4x3d.`positiveY(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`positiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` matrix is applied.
`Vector3d`	Quaterniond.`positiveY(Vector3d dir)`
`Vector3d`	Quaterniondc.`positiveY(Vector3d dir)`	Obtain the direction of `+Y` before the rotation transformation represented by `this` quaternion is applied.
`Vector3d`	Matrix3d.`positiveZ(Vector3d dir)`
`Vector3d`	Matrix3dc.`positiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4d.`positiveZ(Vector3d dir)`
`Vector3d`	Matrix4dc.`positiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4x3d.`positiveZ(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`positiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` matrix is applied.
`Vector3d`	Quaterniond.`positiveZ(Vector3d dir)`
`Vector3d`	Quaterniondc.`positiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the rotation transformation represented by `this` quaternion is applied.
`Vector3d`	Matrix4d.`project(double x, double y, double z, int[] viewport, Vector3d winCoordsDest)`
`Vector3d`	Matrix4d.`project(Vector3dc position, int[] viewport, Vector3d dest)`
`Vector3d`	Matrix4dc.`project(double x, double y, double z, int[] viewport, Vector3d winCoordsDest)`	Project the given `(x, y, z)` position via `this` matrix using the specified viewport and store the resulting window coordinates in `winCoordsDest`.
`Vector3d`	Matrix4dc.`project(Vector3dc position, int[] viewport, Vector3d winCoordsDest)`	Project the given `position` via `this` matrix using the specified viewport and store the resulting window coordinates in `winCoordsDest`.
`Vector3d`	Vector3d.`reflect(double x, double y, double z)`	Reflect this vector about the given normal vector.
`Vector3d`	Vector3d.`reflect(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`reflect(Vector3dc normal)`	Reflect this vector about the given normal vector.
`Vector3d`	Vector3d.`reflect(Vector3dc normal, Vector3d dest)`
`Vector3d`	Vector3dc.`reflect(double x, double y, double z, Vector3d dest)`	Reflect this vector about the given normal vector and store the result in `dest`.
`Vector3d`	Vector3dc.`reflect(Vector3dc normal, Vector3d dest)`	Reflect this vector about the given normal vector and store the result in `dest`.
`Vector3d`	Vector3d.`rotate(Quaterniondc quat)`	Rotate this vector by the given quaternion `quat` and store the result in `this`.
`Vector3d`	Vector3d.`rotate(Quaterniondc quat, Vector3d dest)`
`Vector3d`	Vector3dc.`rotate(Quaterniondc quat, Vector3d dest)`	Rotate this vector by the given quaternion `quat` and store the result in `dest`.
`Vector3d`	Vector3d.`rotateAxis(double angle, double x, double y, double z)`	Rotate this vector the specified radians around the given rotation axis.
`Vector3d`	Vector3d.`rotateAxis(double angle, double aX, double aY, double aZ, Vector3d dest)`
`Vector3d`	Vector3dc.`rotateAxis(double angle, double aX, double aY, double aZ, Vector3d dest)`	Rotate this vector the specified radians around the given rotation axis and store the result into `dest`.
`Vector3d`	Vector3d.`rotateX(double angle)`	Rotate this vector the specified radians around the X axis.
`Vector3d`	Vector3d.`rotateX(double angle, Vector3d dest)`
`Vector3d`	Vector3dc.`rotateX(double angle, Vector3d dest)`	Rotate this vector the specified radians around the X axis and store the result into `dest`.
`Vector3d`	Vector3d.`rotateY(double angle)`	Rotate this vector the specified radians around the Y axis.
`Vector3d`	Vector3d.`rotateY(double angle, Vector3d dest)`
`Vector3d`	Vector3dc.`rotateY(double angle, Vector3d dest)`	Rotate this vector the specified radians around the Y axis and store the result into `dest`.
`Vector3d`	Vector3d.`rotateZ(double angle)`	Rotate this vector the specified radians around the Z axis.
`Vector3d`	Vector3d.`rotateZ(double angle, Vector3d dest)`
`Vector3d`	Vector3dc.`rotateZ(double angle, Vector3d dest)`	Rotate this vector the specified radians around the Z axis and store the result into `dest`.
`Vector3d`	Vector3d.`round()`	Set each component of this vector to the closest double that is equal to a mathematical integer, with ties rounding to positive infinity.
`Vector3d`	Vector3d.`round(Vector3d dest)`
`Vector3d`	Vector3dc.`round(Vector3d dest)`	Compute for each component of this vector the closest double that is equal to a mathematical integer, with ties rounding to positive infinity and store the result in `dest`.
`Vector3d`	Vector3d.`set(double d)`	Set the x, y, and z components to the supplied value.
`Vector3d`	Vector3d.`set(double[] xyz)`	Set the three components of this vector to the first three elements of the given array.
`Vector3d`	Vector3d.`set(double x, double y, double z)`	Set the x, y and z components to the supplied values.
`Vector3d`	Vector3d.`set(float[] xyz)`	Set the three components of this vector to the first three elements of the given array.
`Vector3d`	Vector3d.`set(int index, java.nio.ByteBuffer buffer)`	Read this vector from the supplied `ByteBuffer` starting at the specified absolute buffer position/index.
`Vector3d`	Vector3d.`set(int index, java.nio.DoubleBuffer buffer)`	Read this vector from the supplied `DoubleBuffer` starting at the specified absolute buffer position/index.
`Vector3d`	Vector3d.`set(java.nio.ByteBuffer buffer)`	Read this vector from the supplied `ByteBuffer` at the current buffer `position`.
`Vector3d`	Vector3d.`set(java.nio.DoubleBuffer buffer)`	Read this vector from the supplied `DoubleBuffer` at the current buffer `position`.
`Vector3d`	Vector3d.`set(Vector2dc v, double z)`	Set the first two components from the given `v` and the z component from the given `z`
`Vector3d`	Vector3d.`set(Vector2fc v, double z)`	Set the first two components from the given `v` and the z component from the given `z`
`Vector3d`	Vector3d.`set(Vector2ic v, double z)`	Set the first two components from the given `v` and the z component from the given `z`
`Vector3d`	Vector3d.`set(Vector3dc v)`	Set the x, y and z components to match the supplied vector.
`Vector3d`	Vector3d.`set(Vector3fc v)`	Set the x, y and z components to match the supplied vector.
`Vector3d`	Vector3d.`set(Vector3ic v)`	Set the x, y and z components to match the supplied vector.
`Vector3d`	Vector3d.`setComponent(int component, double value)`	Set the value of the specified component of this vector.
`Vector3d`	Vector3d.`setFromAddress(long address)`	Set the values of this vector by reading 3 double values from off-heap memory, starting at the given address.
`Vector3d`	Vector3d.`smoothStep(Vector3dc v, double t, Vector3d dest)`
`Vector3d`	Vector3dc.`smoothStep(Vector3dc v, double t, Vector3d dest)`	Compute a smooth-step (i.e.
`Vector3d`	Vector3d.`sub(double x, double y, double z)`	Subtract `(x, y, z)` from this vector.
`Vector3d`	Vector3d.`sub(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`sub(Vector3dc v)`	Subtract the supplied vector from this one.
`Vector3d`	Vector3d.`sub(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3d.`sub(Vector3fc v)`	Subtract the supplied vector from this one.
`Vector3d`	Vector3d.`sub(Vector3fc v, Vector3d dest)`
`Vector3d`	Vector3dc.`sub(double x, double y, double z, Vector3d dest)`	Subtract `(x, y, z)` from this vector and store the result in `dest`.
`Vector3d`	Vector3dc.`sub(Vector3dc v, Vector3d dest)`	Subtract the supplied vector from this one and store the result in `dest`.
`Vector3d`	Vector3dc.`sub(Vector3fc v, Vector3d dest)`	Subtract the supplied vector from this one and store the result in `dest`.
`Vector3d`	AxisAngle4d.`transform(Vector3d v)`	Transform the given vector by the rotation transformation described by this `AxisAngle4d`.
`Vector3d`	AxisAngle4d.`transform(Vector3dc v, Vector3d dest)`	Transform the given vector by the rotation transformation described by this `AxisAngle4d` and store the result in `dest`.
`Vector3d`	Matrix3d.`transform(double x, double y, double z, Vector3d dest)`
`Vector3d`	Matrix3d.`transform(Vector3d v)`
`Vector3d`	Matrix3d.`transform(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix3dc.`transform(double x, double y, double z, Vector3d dest)`	Transform the vector `(x, y, z)` by this matrix and store the result in `dest`.
`Vector3d`	Matrix3dc.`transform(Vector3d v)`	Transform the given vector by this matrix.
`Vector3d`	Matrix3dc.`transform(Vector3dc v, Vector3d dest)`	Transform the given vector by this matrix and store the result in `dest`.
`Vector3d`	Matrix3x2d.`transform(double x, double y, double z, Vector3d dest)`	Transform/multiply the given vector `(x, y, z)` by this matrix and store the result in `dest`.
`Vector3d`	Matrix3x2d.`transform(Vector3d v)`	Transform/multiply the given vector by this matrix by assuming a third row in this matrix of `(0, 0, 1)` and store the result in that vector.
`Vector3d`	Matrix3x2d.`transform(Vector3dc v, Vector3d dest)`	Transform/multiply the given vector by this matrix by assuming a third row in this matrix of `(0, 0, 1)` and store the result in `dest`.
`Vector3d`	Matrix3x2dc.`transform(double x, double y, double z, Vector3d dest)`	Transform/multiply the given vector `(x, y, z)` by this matrix and store the result in `dest`.
`Vector3d`	Matrix3x2dc.`transform(Vector3d v)`	Transform/multiply the given vector by this matrix by assuming a third row in this matrix of `(0, 0, 1)` and store the result in that vector.
`Vector3d`	Matrix3x2dc.`transform(Vector3dc v, Vector3d dest)`	Transform/multiply the given vector by this matrix and store the result in `dest`.
`Vector3d`	Quaterniond.`transform(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaterniond.`transform(Vector3d vec)`
`Vector3d`	Quaterniond.`transform(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaterniondc.`transform(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this quaternion and store the result in `dest`.
`Vector3d`	Quaterniondc.`transform(Vector3d vec)`	Transform the given vector by this quaternion.
`Vector3d`	Quaterniondc.`transform(Vector3dc vec, Vector3d dest)`	Transform the given vector by this quaternion and store the result in `dest`.
`Vector3d`	Quaternionf.`transform(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaternionf.`transform(float x, float y, float z, Vector3d dest)`
`Vector3d`	Quaternionf.`transform(Vector3d vec)`
`Vector3d`	Quaternionf.`transform(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaternionfc.`transform(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transform(float x, float y, float z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transform(Vector3d vec)`	Transform the given vector by this quaternion.
`Vector3d`	Quaternionfc.`transform(Vector3dc vec, Vector3d dest)`	Transform the given vector by this quaternion and store the result in `dest`.
`Vector3d`	Matrix4d.`transformDirection(double x, double y, double z, Vector3d dest)`
`Vector3d`	Matrix4d.`transformDirection(Vector3d dest)`
`Vector3d`	Matrix4d.`transformDirection(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix4dc.`transformDirection(double x, double y, double z, Vector3d dest)`	Transform/multiply the 3D-vector `(x, y, z)`, as if it was a 4D-vector with w=0, by this matrix and store the result in `dest`.
`Vector3d`	Matrix4dc.`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 that vector.
`Vector3d`	Matrix4dc.`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 `dest`.
`Vector3d`	Matrix4x3d.`transformDirection(Vector3d v)`
`Vector3d`	Matrix4x3d.`transformDirection(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix4x3dc.`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 that vector.
`Vector3d`	Matrix4x3dc.`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 `dest`.
`Vector3d`	Quaterniond.`transformInverse(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaterniond.`transformInverse(Vector3d vec)`
`Vector3d`	Quaterniond.`transformInverse(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaterniondc.`transformInverse(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this quaternion and store the result in `dest`.
`Vector3d`	Quaterniondc.`transformInverse(Vector3d vec)`	Transform the given vector by the inverse of this quaternion.
`Vector3d`	Quaterniondc.`transformInverse(Vector3dc vec, Vector3d dest)`	Transform the given vector by the inverse of this quaternion and store the result in `dest`.
`Vector3d`	Quaternionf.`transformInverse(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformInverse(float x, float y, float z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformInverse(Vector3d vec)`
`Vector3d`	Quaternionf.`transformInverse(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaternionfc.`transformInverse(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformInverse(float x, float y, float z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformInverse(Vector3d vec)`	Transform the given vector by the inverse of this quaternion.
`Vector3d`	Quaternionfc.`transformInverse(Vector3dc vec, Vector3d dest)`	Transform the given vector by the inverse of this quaternion and store the result in `dest`.
`Vector3d`	Quaterniond.`transformInverseUnit(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaterniond.`transformInverseUnit(Vector3d vec)`
`Vector3d`	Quaterniond.`transformInverseUnit(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaterniondc.`transformInverseUnit(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this unit quaternion and store the result in `dest`.
`Vector3d`	Quaterniondc.`transformInverseUnit(Vector3d vec)`	Transform the given vector by the inverse of this unit quaternion.
`Vector3d`	Quaterniondc.`transformInverseUnit(Vector3dc vec, Vector3d dest)`	Transform the given vector by the inverse of this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionf.`transformInverseUnit(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformInverseUnit(float x, float y, float z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformInverseUnit(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaternionfc.`transformInverseUnit(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformInverseUnit(float x, float y, float z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformInverseUnit(Vector3dc vec, Vector3d dest)`	Transform the given vector by the inverse of this unit quaternion and store the result in `dest`.
`Vector3d`	Matrix4d.`transformPosition(double x, double y, double z, Vector3d dest)`
`Vector3d`	Matrix4d.`transformPosition(Vector3d dest)`
`Vector3d`	Matrix4d.`transformPosition(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix4dc.`transformPosition(double x, double y, double z, Vector3d dest)`	Transform/multiply the 3D-vector `(x, y, z)`, as if it was a 4D-vector with w=1, by this matrix and store the result in `dest`.
`Vector3d`	Matrix4dc.`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 that vector.
`Vector3d`	Matrix4dc.`transformPosition(Vector3dc v, 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 `dest`.
`Vector3d`	Matrix4x3d.`transformPosition(Vector3d v)`
`Vector3d`	Matrix4x3d.`transformPosition(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix4x3dc.`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 that vector.
`Vector3d`	Matrix4x3dc.`transformPosition(Vector3dc v, 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 `dest`.
`Vector3d`	Quaterniond.`transformPositiveX(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformPositiveX(Vector3d dest)`	Transform the vector `(1, 0, 0)` by this quaternion.
`Vector3d`	Quaternionf.`transformPositiveX(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformPositiveX(Vector3d dest)`	Transform the vector `(1, 0, 0)` by this quaternion.
`Vector3d`	Quaterniond.`transformPositiveY(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformPositiveY(Vector3d dest)`	Transform the vector `(0, 1, 0)` by this quaternion.
`Vector3d`	Quaternionf.`transformPositiveY(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformPositiveY(Vector3d dest)`	Transform the vector `(0, 1, 0)` by this quaternion.
`Vector3d`	Quaterniond.`transformPositiveZ(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformPositiveZ(Vector3d dest)`	Transform the vector `(0, 0, 1)` by this quaternion.
`Vector3d`	Quaternionf.`transformPositiveZ(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformPositiveZ(Vector3d dest)`	Transform the vector `(0, 0, 1)` by this quaternion.
`Vector3d`	Matrix4d.`transformProject(double x, double y, double z, double w, Vector3d dest)`
`Vector3d`	Matrix4d.`transformProject(double x, double y, double z, Vector3d dest)`
`Vector3d`	Matrix4d.`transformProject(Vector3d v)`
`Vector3d`	Matrix4d.`transformProject(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix4d.`transformProject(Vector4dc v, Vector3d dest)`
`Vector3d`	Matrix4dc.`transformProject(double x, double y, double z, double w, Vector3d dest)`	Transform/multiply the vector `(x, y, z, w)` by this matrix, perform perspective divide and store `(x, y, z)` of the result in `dest`.
`Vector3d`	Matrix4dc.`transformProject(double x, double y, double z, Vector3d dest)`	Transform/multiply the vector `(x, y, z)` by this matrix, perform perspective divide and store the result in `dest`.
`Vector3d`	Matrix4dc.`transformProject(Vector3d v)`	Transform/multiply the given vector by this matrix, perform perspective divide and store the result in that vector.
`Vector3d`	Matrix4dc.`transformProject(Vector3dc v, Vector3d dest)`	Transform/multiply the given vector by this matrix, perform perspective divide and store the result in `dest`.
`Vector3d`	Matrix4dc.`transformProject(Vector4dc v, Vector3d dest)`	Transform/multiply the given vector by this matrix, perform perspective divide and store the `x`, `y` and `z` components of the result in `dest`.
`Vector3d`	Matrix3d.`transformTranspose(double x, double y, double z, Vector3d dest)`
`Vector3d`	Matrix3d.`transformTranspose(Vector3d v)`
`Vector3d`	Matrix3d.`transformTranspose(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix3dc.`transformTranspose(double x, double y, double z, Vector3d dest)`	Transform the vector `(x, y, z)` by the transpose of this matrix and store the result in `dest`.
`Vector3d`	Matrix3dc.`transformTranspose(Vector3d v)`	Transform the given vector by the transpose of this matrix.
`Vector3d`	Matrix3dc.`transformTranspose(Vector3dc v, Vector3d dest)`	Transform the given vector by the transpose of this matrix and store the result in `dest`.
`Vector3d`	Quaterniond.`transformUnit(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaterniond.`transformUnit(Vector3d vec)`
`Vector3d`	Quaterniond.`transformUnit(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaterniondc.`transformUnit(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this unit quaternion and store the result in `dest`.
`Vector3d`	Quaterniondc.`transformUnit(Vector3d vec)`	Transform the given vector by this unit quaternion.
`Vector3d`	Quaterniondc.`transformUnit(Vector3dc vec, Vector3d dest)`	Transform the given vector by this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionf.`transformUnit(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformUnit(float x, float y, float z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformUnit(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaternionfc.`transformUnit(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformUnit(float x, float y, float z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformUnit(Vector3dc vec, Vector3d dest)`	Transform the given vector by this unit quaternion and store the result in `dest`.
`Vector3d`	Quaterniond.`transformUnitPositiveX(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformUnitPositiveX(Vector3d dest)`	Transform the vector `(1, 0, 0)` by this unit quaternion.
`Vector3d`	Quaternionf.`transformUnitPositiveX(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformUnitPositiveX(Vector3d dest)`	Transform the vector `(1, 0, 0)` by this unit quaternion.
`Vector3d`	Quaterniond.`transformUnitPositiveY(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformUnitPositiveY(Vector3d dest)`	Transform the vector `(0, 1, 0)` by this unit quaternion.
`Vector3d`	Quaternionf.`transformUnitPositiveY(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformUnitPositiveY(Vector3d dest)`	Transform the vector `(0, 1, 0)` by this unit quaternion.
`Vector3d`	Quaterniond.`transformUnitPositiveZ(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformUnitPositiveZ(Vector3d dest)`	Transform the vector `(0, 0, 1)` by this unit quaternion.
`Vector3d`	Quaternionf.`transformUnitPositiveZ(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformUnitPositiveZ(Vector3d dest)`	Transform the vector `(0, 0, 1)` by this unit quaternion.
`Vector3d`	Matrix4d.`unproject(double winX, double winY, double winZ, int[] viewport, Vector3d dest)`
`Vector3d`	Matrix4d.`unproject(Vector3dc winCoords, int[] viewport, Vector3d dest)`
`Vector3d`	Matrix4dc.`unproject(double winX, double winY, double winZ, int[] viewport, Vector3d dest)`	Unproject the given window coordinates `(winX, winY, winZ)` by `this` matrix using the specified viewport.
`Vector3d`	Matrix4dc.`unproject(Vector3dc winCoords, int[] viewport, Vector3d dest)`	Unproject the given window coordinates `winCoords` by `this` matrix using the specified viewport.
`Vector3d`	Matrix4d.`unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector3d dest)`
`Vector3d`	Matrix4d.`unprojectInv(Vector3dc winCoords, int[] viewport, Vector3d dest)`
`Vector3d`	Matrix4dc.`unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector3d dest)`	Unproject the given window coordinates `(winX, winY, winZ)` by `this` matrix using the specified viewport.
`Vector3d`	Matrix4dc.`unprojectInv(Vector3dc winCoords, int[] viewport, Vector3d dest)`	Unproject the given window coordinates `winCoords` by `this` matrix using the specified viewport.
`Vector3d`	Vector3d.`zero()`	Set all components to zero.

Methods in org.joml with parameters of type Vector3d
Modifier and Type	Method	Description
`Vector3d`	Vector3d.`absolute(Vector3d dest)`
`Vector3d`	Vector3dc.`absolute(Vector3d dest)`	Compute the absolute values of the individual components of `this` and store the result in `dest`.
`Vector3d`	Vector3d.`add(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`add(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3d.`add(Vector3fc v, Vector3d dest)`
`Vector3d`	Vector3dc.`add(double x, double y, double z, Vector3d dest)`	Increment the components of this vector by the given values and store the result in `dest`.
`Vector3d`	Vector3dc.`add(Vector3dc v, Vector3d dest)`	Add the supplied vector to this one and store the result in `dest`.
`Vector3d`	Vector3dc.`add(Vector3fc v, Vector3d dest)`	Add the supplied vector to this one and store the result in `dest`.
`Matrix4d`	Matrix4d.`affineSpan(Vector3d corner, Vector3d xDir, Vector3d yDir, Vector3d zDir)`	Compute the extents of the coordinate system before this `affine` transformation was applied and store the resulting corner coordinates in `corner` and the span vectors in `xDir`, `yDir` and `zDir`.
`Vector3d`	Vector3d.`ceil(Vector3d dest)`
`Vector3d`	Vector3dc.`ceil(Vector3d dest)`	Compute for each component of this vector the smallest (closest to negative infinity) `double` value that is greater than or equal to that component and is equal to a mathematical integer and store the result in `dest`.
`Vector3d`	Vector3d.`cross(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`cross(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3dc.`cross(double x, double y, double z, Vector3d dest)`	Compute the cross product of this vector and `(x, y, z)` and store the result in `dest`.
`Vector3d`	Vector3dc.`cross(Vector3dc v, Vector3d dest)`	Calculate the cross product of this and v2 and store the result in `dest`.
`Vector3d`	Vector3d.`div(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`div(double scalar, Vector3d dest)`
`Vector3d`	Vector3d.`div(Vector3d v)`	Divide this Vector3d component-wise by another Vector3dc.
`Vector3d`	Vector3d.`div(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3d.`div(Vector3fc v, Vector3d dest)`
`Vector3d`	Vector3dc.`div(double x, double y, double z, Vector3d dest)`	Divide the components of this Vector3f by the given scalar values and store the result in `dest`.
`Vector3d`	Vector3dc.`div(double scalar, Vector3d dest)`	Divide this Vector3d by the given scalar value and store the result in `dest`.
`Vector3d`	Vector3dc.`div(Vector3dc v, Vector3d dest)`	Divide this by `v` component-wise and store the result into `dest`.
`Vector3d`	Vector3dc.`div(Vector3fc v, Vector3d dest)`	Divide this Vector3d component-wise by another Vector3f and store the result in `dest`.
`static Vector3d`	Intersectiond.`findClosestPointOnLineSegment(double aX, double aY, double aZ, double bX, double bY, double bZ, double pX, double pY, double pZ, Vector3d result)`	Find the point on the given line segment which is closest to the specified point `(pX, pY, pZ)`, and store the result in `result`.
`static Vector3d`	Intersectiond.`findClosestPointOnPlane(double aX, double aY, double aZ, double nX, double nY, double nZ, double pX, double pY, double pZ, Vector3d result)`	Find the point on the given plane which is closest to the specified point `(pX, pY, pZ)` and store the result in `result`.
`static Vector3d`	Intersectiond.`findClosestPointOnRectangle(double aX, double aY, double aZ, double bX, double bY, double bZ, double cX, double cY, double cZ, double pX, double pY, double pZ, Vector3d res)`	Find the point on a given rectangle, specified via three of its corners, which is closest to the specified point `(pX, pY, pZ)` and store the result into `res`.
`static int`	Intersectiond.`findClosestPointOnTriangle(double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, double pX, double pY, double pZ, Vector3d result)`	Determine the closest point on the triangle with the given vertices `(v0X, v0Y, v0Z)`, `(v1X, v1Y, v1Z)`, `(v2X, v2Y, v2Z)` between that triangle and the given point `(pX, pY, pZ)` and store that point into the given `result`.
`static int`	Intersectiond.`findClosestPointOnTriangle(Vector3dc v0, Vector3dc v1, Vector3dc v2, Vector3dc p, Vector3d result)`	Determine the closest point on the triangle with the vertices `v0`, `v1`, `v2` between that triangle and the given point `p` and store that point into the given `result`.
`static double`	Intersectiond.`findClosestPointsLineSegments(double a0X, double a0Y, double a0Z, double a1X, double a1Y, double a1Z, double b0X, double b0Y, double b0Z, double b1X, double b1Y, double b1Z, Vector3d resultA, Vector3d resultB)`	Find the closest points on the two line segments, store the point on the first line segment in `resultA` and the point on the second line segment in `resultB`, and return the square distance between both points.
`static double`	Intersectiond.`findClosestPointsLineSegmentTriangle(double aX, double aY, double aZ, double bX, double bY, double bZ, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, Vector3d lineSegmentResult, Vector3d triangleResult)`	Find the closest points on a line segment and a triangle.
`Vector3d`	Vector3d.`floor(Vector3d dest)`
`Vector3d`	Vector3dc.`floor(Vector3d dest)`	Compute for each component of this vector the largest (closest to positive infinity) `double` value that is less than or equal to that component and is equal to a mathematical integer and store the result in `dest`.
`Vector3d`	Vector3d.`fma(double a, Vector3dc b, Vector3d dest)`
`Vector3d`	Vector3d.`fma(double a, Vector3fc b, Vector3d dest)`
`Vector3d`	Vector3d.`fma(Vector3dc a, Vector3dc b, Vector3d dest)`
`Vector3d`	Vector3d.`fma(Vector3dc a, Vector3fc b, Vector3d dest)`
`Vector3d`	Vector3d.`fma(Vector3fc a, Vector3fc b, Vector3d dest)`
`Vector3d`	Vector3dc.`fma(double a, Vector3dc b, Vector3d dest)`	Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector3d`	Vector3dc.`fma(double a, Vector3fc b, Vector3d dest)`	Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector3d`	Vector3dc.`fma(Vector3dc a, Vector3dc b, Vector3d dest)`	Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector3d`	Vector3dc.`fma(Vector3dc a, Vector3fc b, Vector3d dest)`	Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector3d`	Vector3dc.`fma(Vector3fc a, Vector3fc b, Vector3d dest)`	Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Matrix4d`	Matrix4d.`frustumAabb(Vector3d min, Vector3d max)`	Compute the axis-aligned bounding box of the frustum described by `this` matrix and store the minimum corner coordinates in the given `min` and the maximum corner coordinates in the given `max` vector.
`Vector3d`	Matrix4d.`frustumCorner(int corner, Vector3d dest)`
`Vector3d`	Matrix4dc.`frustumCorner(int corner, Vector3d point)`	Compute the corner coordinates of the frustum defined by `this` matrix, which can be a projection matrix or a combined modelview-projection matrix, and store the result in the given `point`.
`Vector3d`	Matrix4d.`frustumRayDir(double x, double y, Vector3d dest)`
`Vector3d`	Matrix4dc.`frustumRayDir(double x, double y, Vector3d dir)`	Obtain the direction of a ray starting at the center of the coordinate system and going through the near frustum plane.
`Vector3d`	Vector3d.`get(Vector3d dest)`
`Vector3d`	Vector3dc.`get(Vector3d dest)`	Set the components of the given vector `dest` to those of `this` vector.
`Vector3d`	Vector3f.`get(Vector3d dest)`
`Vector3d`	Vector3fc.`get(Vector3d dest)`	Set the components of the given vector `dest` to those of `this` vector.
`Vector3d`	Matrix3d.`getColumn(int column, Vector3d dest)`
`Vector3d`	Matrix3dc.`getColumn(int column, Vector3d dest)`	Get the column at the given `column` index, starting with `0`.
`Vector3d`	Matrix4d.`getColumn(int column, Vector3d dest)`
`Vector3d`	Matrix4dc.`getColumn(int column, Vector3d dest)`	Get the first three components of the column at the given `column` index, starting with `0`.
`Vector3d`	Matrix4x3d.`getColumn(int column, Vector3d dest)`
`Vector3d`	Matrix4x3dc.`getColumn(int column, Vector3d dest)`	Get the column at the given `column` index, starting with `0`.
`Vector3d`	Matrix3d.`getEulerAnglesXYZ(Vector3d dest)`
`Vector3d`	Matrix3dc.`getEulerAnglesXYZ(Vector3d dest)`	Extract the Euler angles from the rotation represented by `this` matrix and store the extracted Euler angles in `dest`.
`Vector3d`	Matrix4d.`getEulerAnglesXYZ(Vector3d dest)`
`Vector3d`	Matrix4dc.`getEulerAnglesXYZ(Vector3d dest)`	Extract the Euler angles from the rotation represented by the upper left 3x3 submatrix of `this` and store the extracted Euler angles in `dest`.
`Vector3d`	Matrix4x3d.`getEulerAnglesXYZ(Vector3d dest)`
`Vector3d`	Matrix4x3dc.`getEulerAnglesXYZ(Vector3d dest)`	Extract the Euler angles from the rotation represented by the left 3x3 submatrix of `this` and store the extracted Euler angles in `dest`.
`Vector3d`	Quaterniond.`getEulerAnglesXYZ(Vector3d eulerAngles)`
`Vector3d`	Quaterniondc.`getEulerAnglesXYZ(Vector3d eulerAngles)`	Get the euler angles in radians in rotation sequence `XYZ` of this quaternion and store them in the provided parameter `eulerAngles`.
`Vector3d`	Quaterniond.`getEulerAnglesYXZ(Vector3d eulerAngles)`
`Vector3d`	Quaterniondc.`getEulerAnglesYXZ(Vector3d eulerAngles)`	Get the euler angles in radians in rotation sequence `YXZ` of this quaternion and store them in the provided parameter `eulerAngles`.
`Vector3d`	Quaterniond.`getEulerAnglesZXY(Vector3d eulerAngles)`
`Vector3d`	Quaterniondc.`getEulerAnglesZXY(Vector3d eulerAngles)`	Get the euler angles in radians in rotation sequence `ZXY` of this quaternion and store them in the provided parameter `eulerAngles`.
`Vector3d`	Matrix3d.`getEulerAnglesZYX(Vector3d dest)`
`Vector3d`	Matrix3dc.`getEulerAnglesZYX(Vector3d dest)`	Extract the Euler angles from the rotation represented by `this` matrix and store the extracted Euler angles in `dest`.
`Vector3d`	Matrix4d.`getEulerAnglesZYX(Vector3d dest)`
`Vector3d`	Matrix4dc.`getEulerAnglesZYX(Vector3d dest)`	Extract the Euler angles from the rotation represented by the upper left 3x3 submatrix of `this` and store the extracted Euler angles in `dest`.
`Vector3d`	Matrix4x3d.`getEulerAnglesZYX(Vector3d dest)`
`Vector3d`	Matrix4x3dc.`getEulerAnglesZYX(Vector3d dest)`	Extract the Euler angles from the rotation represented by the left 3x3 submatrix of `this` and store the extracted Euler angles in `dest`.
`Vector3d`	Quaterniond.`getEulerAnglesZYX(Vector3d eulerAngles)`
`Vector3d`	Quaterniondc.`getEulerAnglesZYX(Vector3d eulerAngles)`	Get the euler angles in radians in rotation sequence `ZYX` of this quaternion and store them in the provided parameter `eulerAngles`.
`Vector3d`	Matrix3d.`getRow(int row, Vector3d dest)`
`Vector3d`	Matrix3dc.`getRow(int row, Vector3d dest)`	Get the row at the given `row` index, starting with `0`.
`Vector3d`	Matrix4d.`getRow(int row, Vector3d dest)`
`Vector3d`	Matrix4dc.`getRow(int row, Vector3d dest)`	Get the first three components of the row at the given `row` index, starting with `0`.
`Vector3d`	Matrix3d.`getScale(Vector3d dest)`
`Vector3d`	Matrix3dc.`getScale(Vector3d dest)`	Get the scaling factors of `this` matrix for the three base axes.
`Vector3d`	Matrix4d.`getScale(Vector3d dest)`
`Vector3d`	Matrix4dc.`getScale(Vector3d dest)`	Get the scaling factors of `this` matrix for the three base axes.
`Vector3d`	Matrix4x3d.`getScale(Vector3d dest)`
`Vector3d`	Matrix4x3dc.`getScale(Vector3d dest)`	Get the scaling factors of `this` matrix for the three base axes.
`Vector3d`	Matrix4d.`getTranslation(Vector3d dest)`
`Vector3d`	Matrix4dc.`getTranslation(Vector3d dest)`	Get only the translation components `(m30, m31, m32)` of this matrix and store them in the given vector `xyz`.
`Vector3d`	Matrix4x3d.`getTranslation(Vector3d dest)`
`Vector3d`	Matrix4x3dc.`getTranslation(Vector3d dest)`	Get only the translation components `(m30, m31, m32)` of this matrix and store them in the given vector `xyz`.
`Vector3d`	Vector3d.`half(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`half(Vector3dc other, Vector3d dest)`
`Vector3d`	Vector3dc.`half(double x, double y, double z, Vector3d dest)`	Compute the half vector between this and the vector `(x, y, z)` and store the result in `dest`.
`Vector3d`	Vector3dc.`half(Vector3dc other, Vector3d dest)`	Compute the half vector between this and the other vector and store the result in `dest`.
`Vector3d`	Vector3d.`hermite(Vector3dc t0, Vector3dc v1, Vector3dc t1, double t, Vector3d dest)`
`Vector3d`	Vector3dc.`hermite(Vector3dc t0, Vector3dc v1, Vector3dc t1, double t, Vector3d dest)`	Compute a hermite interpolation between `this` vector and its associated tangent `t0` and the given vector `v` with its tangent `t1` and store the result in `dest`.
`static Vector3d`	Interpolationd.`interpolateTriangle(double v0X, double v0Y, double f0X, double f0Y, double f0Z, double v1X, double v1Y, double f1X, double f1Y, double f1Z, double v2X, double v2Y, double f2X, double f2Y, double f2Z, double x, double y, Vector3d dest)`	Bilinearly interpolate the three-dimensional vector f over the given triangle and store the result in `dest`.
`static Vector3d`	Interpolationd.`interpolationFactorsTriangle(double v0X, double v0Y, double v1X, double v1Y, double v2X, double v2Y, double x, double y, Vector3d dest)`	Compute the interpolation factors `(t0, t1, t2)` in order to interpolate an arbitrary value over a given triangle at the given point `(x, y)`.
`static boolean`	Intersectiond.`intersectCircleCircle(double aX, double aY, double radiusSquaredA, double bX, double bY, double radiusSquaredB, Vector3d intersectionCenterAndHL)`	Test whether the one circle with center `(aX, aY)` and square radius `radiusSquaredA` intersects the other circle with center `(bX, bY)` and square radius `radiusSquaredB`, and store the center of the line segment of intersection in the `(x, y)` components of the supplied vector and the half-length of that line segment in the z component.
`static boolean`	Intersectiond.`intersectCircleCircle(Vector2dc centerA, double radiusSquaredA, Vector2dc centerB, double radiusSquaredB, Vector3d intersectionCenterAndHL)`	Test whether the one circle with center `centerA` and square radius `radiusSquaredA` intersects the other circle with center `centerB` and square radius `radiusSquaredB`, and store the center of the line segment of intersection in the `(x, y)` components of the supplied vector and the half-length of that line segment in the z component.
`static boolean`	Intersectiond.`intersectLineCircle(double x0, double y0, double x1, double y1, double centerX, double centerY, double radius, Vector3d intersectionCenterAndHL)`	Test whether the line defined by the two points `(x0, y0)` and `(x1, y1)` intersects the circle with center `(centerX, centerY)` and `radius`, and store the center of the line segment of intersection in the `(x, y)` components of the supplied vector and the half-length of that line segment in the z component.
`static boolean`	Intersectiond.`intersectLineCircle(double a, double b, double c, double centerX, double centerY, double radius, Vector3d intersectionCenterAndHL)`	Test whether the line with the general line equation ax + by + c = 0 intersects the circle with center `(centerX, centerY)` and `radius`, and store the center of the line segment of intersection in the `(x, y)` components of the supplied vector and the half-length of that line segment in the z component.
`static boolean`	Intersectiond.`intersectLineSegmentPlane(double p0X, double p0Y, double p0Z, double p1X, double p1Y, double p1Z, double a, double b, double c, double d, Vector3d intersectionPoint)`	Determine whether the line segment with the end points `(p0X, p0Y, p0Z)` and `(p1X, p1Y, p1Z)` intersects the plane given as the general plane equation ax + by + cz + d = 0*, and return the point of intersection.
`static boolean`	Intersectiond.`intersectLineSegmentTriangle(double p0X, double p0Y, double p0Z, double p1X, double p1Y, double p1Z, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, double epsilon, Vector3d intersectionPoint)`	Determine whether the line segment with the end points `(p0X, p0Y, p0Z)` and `(p1X, p1Y, p1Z)` intersects the triangle consisting of the three vertices `(v0X, v0Y, v0Z)`, `(v1X, v1Y, v1Z)` and `(v2X, v2Y, v2Z)`, regardless of the winding order of the triangle or the direction of the line segment between its two end points, and return the point of intersection.
`static boolean`	Intersectiond.`intersectLineSegmentTriangle(Vector3dc p0, Vector3dc p1, Vector3dc v0, Vector3dc v1, Vector3dc v2, double epsilon, Vector3d intersectionPoint)`	Determine whether the line segment with the end points `p0` and `p1` intersects the triangle consisting of the three vertices `(v0X, v0Y, v0Z)`, `(v1X, v1Y, v1Z)` and `(v2X, v2Y, v2Z)`, regardless of the winding order of the triangle or the direction of the line segment between its two end points, and return the point of intersection.
`static int`	Intersectiond.`intersectSphereTriangle(double sX, double sY, double sZ, double sR, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, Vector3d result)`	Test whether the given sphere with center `(sX, sY, sZ)` intersects the triangle given by its three vertices, and if they intersect store the point of intersection into `result`.
`Vector3d`	Vector3d.`lerp(Vector3dc other, double t, Vector3d dest)`
`Vector3d`	Vector3dc.`lerp(Vector3dc other, double t, Vector3d dest)`	Linearly interpolate `this` and `other` using the given interpolation factor `t` and store the result in `dest`.
`Vector3d`	Vector3d.`max(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3dc.`max(Vector3dc v, Vector3d dest)`	Set the components of `dest` to be the component-wise maximum of this and the other vector.
`Vector3d`	Vector3d.`min(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3dc.`min(Vector3dc v, Vector3d dest)`	Set the components of `dest` to be the component-wise minimum of this and the other vector.
`Vector3d`	Vector3d.`mul(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`mul(double scalar, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Matrix3dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Matrix3fc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Matrix3x2dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Matrix3x2fc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3d.`mul(Vector3fc v, Vector3d dest)`
`Vector3d`	Vector3dc.`mul(double x, double y, double z, Vector3d dest)`	Multiply the components of this Vector3f by the given scalar values and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(double scalar, Vector3d dest)`	Multiply this Vector3d by the given scalar value and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(Matrix3dc mat, Vector3d dest)`	Multiply the given matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(Matrix3fc mat, Vector3d dest)`	Multiply the given matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(Matrix3x2dc mat, Vector3d dest)`	Multiply the given matrix `mat` with `this` by assuming a third row in the matrix of `(0, 0, 1)` and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(Matrix3x2fc mat, Vector3d dest)`	Multiply the given matrix `mat` with `this` by assuming a third row in the matrix of `(0, 0, 1)` and store the result in `dest`.
`Vector3d`	Vector3dc.`mul(Vector3dc v, Vector3d dest)`	Multiply this by `v` component-wise and store the result into `dest`.
`Vector3d`	Vector3dc.`mul(Vector3fc v, Vector3d dest)`	Multiply this Vector3d component-wise by another Vector3f and store the result in `dest`.
`Vector3d`	Vector3d.`mulAdd(double a, Vector3dc b, Vector3d dest)`
`Vector3d`	Vector3d.`mulAdd(Vector3dc a, Vector3dc b, Vector3d dest)`
`Vector3d`	Vector3d.`mulAdd(Vector3fc a, Vector3dc b, Vector3d dest)`
`Vector3d`	Vector3dc.`mulAdd(double a, Vector3dc b, Vector3d dest)`	Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulAdd(Vector3dc a, Vector3dc b, Vector3d dest)`	Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulAdd(Vector3fc a, Vector3dc b, Vector3d dest)`	Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
`Vector3d`	Vector3d.`mulDirection(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulDirection(Matrix4fc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulDirection(Matrix4x3dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulDirection(Matrix4x3fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulDirection(Matrix4dc mat, Vector3d dest)`	Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulDirection(Matrix4fc mat, Vector3d dest)`	Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulDirection(Matrix4x3dc mat, Vector3d dest)`	Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulDirection(Matrix4x3fc mat, Vector3d dest)`	Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3d.`mulPosition(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulPosition(Matrix4fc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulPosition(Matrix4x3dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulPosition(Matrix4x3fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulPosition(Matrix4dc mat, Vector3d dest)`	Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulPosition(Matrix4fc mat, Vector3d dest)`	Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulPosition(Matrix4x3dc mat, Vector3d dest)`	Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulPosition(Matrix4x3fc mat, Vector3d dest)`	Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.
`double`	Vector3d.`mulPositionW(Matrix4dc mat, Vector3d dest)`
`double`	Vector3d.`mulPositionW(Matrix4fc mat, Vector3d dest)`
`double`	Vector3dc.`mulPositionW(Matrix4dc mat, Vector3d dest)`	Multiply the given 4x4 matrix `mat` with `this`, store the result in `dest` and return the w component of the resulting 4D vector.
`double`	Vector3dc.`mulPositionW(Matrix4fc mat, Vector3d dest)`	Multiply the given 4x4 matrix `mat` with `this`, store the result in `dest` and return the w component of the resulting 4D vector.
`Vector3d`	Vector3d.`mulProject(Matrix4dc mat, double w, Vector3d dest)`
`Vector3d`	Vector3d.`mulProject(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulProject(Matrix4fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulProject(Matrix4dc mat, double w, Vector3d dest)`	Multiply the given matrix `mat` with this Vector3d, perform perspective division and store the result in `dest`.
`Vector3d`	Vector3dc.`mulProject(Matrix4dc mat, Vector3d dest)`	Multiply the given matrix `mat` with this Vector3d, perform perspective division and store the result in `dest`.
`Vector3d`	Vector3dc.`mulProject(Matrix4fc mat, Vector3d dest)`	Multiply the given matrix `mat` with this Vector3d, perform perspective division and store the result in `dest`.
`Vector3d`	Vector4d.`mulProject(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector4dc.`mulProject(Matrix4dc mat, Vector3d dest)`	Multiply the given matrix `mat` with this Vector4d, perform perspective division and store the `(x, y, z)` result in `dest`.
`Vector3d`	Vector3d.`mulTranspose(Matrix3dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulTranspose(Matrix3fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulTranspose(Matrix3dc mat, Vector3d dest)`	Multiply the transpose of the given matrix with this Vector3f and store the result in `dest`.
`Vector3d`	Vector3dc.`mulTranspose(Matrix3fc mat, Vector3d dest)`	Multiply the transpose of the given matrix with this Vector3f and store the result in `dest`.
`Vector3d`	Vector3d.`mulTransposeDirection(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulTransposeDirection(Matrix4fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulTransposeDirection(Matrix4dc mat, Vector3d dest)`	Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulTransposeDirection(Matrix4fc mat, Vector3d dest)`	Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3d.`mulTransposePosition(Matrix4dc mat, Vector3d dest)`
`Vector3d`	Vector3d.`mulTransposePosition(Matrix4fc mat, Vector3d dest)`
`Vector3d`	Vector3dc.`mulTransposePosition(Matrix4dc mat, Vector3d dest)`	Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3dc.`mulTransposePosition(Matrix4fc mat, Vector3d dest)`	Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3d`	Vector3d.`negate(Vector3d dest)`
`Vector3d`	Vector3dc.`negate(Vector3d dest)`	Negate this vector and store the result in `dest`.
`Vector3d`	Vector3d.`normalize(double length, Vector3d dest)`
`Vector3d`	Vector3d.`normalize(Vector3d dest)`
`Vector3d`	Vector3dc.`normalize(double length, Vector3d dest)`	Scale this vector to have the given length and store the result in `dest`.
`Vector3d`	Vector3dc.`normalize(Vector3d dest)`	Normalize this vector and store the result in `dest`.
`Vector3d`	Matrix3d.`normalizedPositiveX(Vector3d dir)`
`Vector3d`	Matrix3dc.`normalizedPositiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4d.`normalizedPositiveX(Vector3d dir)`
`Vector3d`	Matrix4dc.`normalizedPositiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4x3d.`normalizedPositiveX(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`normalizedPositiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Quaterniond.`normalizedPositiveX(Vector3d dir)`
`Vector3d`	Quaterniondc.`normalizedPositiveX(Vector3d dir)`	Obtain the direction of `+X` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3d`	Matrix3d.`normalizedPositiveY(Vector3d dir)`
`Vector3d`	Matrix3dc.`normalizedPositiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4d.`normalizedPositiveY(Vector3d dir)`
`Vector3d`	Matrix4dc.`normalizedPositiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4x3d.`normalizedPositiveY(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`normalizedPositiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Quaterniond.`normalizedPositiveY(Vector3d dir)`
`Vector3d`	Quaterniondc.`normalizedPositiveY(Vector3d dir)`	Obtain the direction of `+Y` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3d`	Matrix3d.`normalizedPositiveZ(Vector3d dir)`
`Vector3d`	Matrix3dc.`normalizedPositiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4d.`normalizedPositiveZ(Vector3d dir)`
`Vector3d`	Matrix4dc.`normalizedPositiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Matrix4x3d.`normalizedPositiveZ(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`normalizedPositiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	Quaterniond.`normalizedPositiveZ(Vector3d dir)`
`Vector3d`	Quaterniondc.`normalizedPositiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3d`	Matrix4d.`origin(Vector3d dest)`
`Vector3d`	Matrix4dc.`origin(Vector3d origin)`	Obtain the position that gets transformed to the origin by `this` matrix.
`Vector3d`	Matrix4x3d.`origin(Vector3d origin)`
`Vector3d`	Matrix4x3dc.`origin(Vector3d origin)`	Obtain the position that gets transformed to the origin by `this` matrix.
`Vector3d`	Matrix4d.`originAffine(Vector3d dest)`
`Vector3d`	Matrix4dc.`originAffine(Vector3d origin)`	Obtain the position that gets transformed to the origin by `this` `affine` matrix.
`Vector3d`	Vector3d.`orthogonalize(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3dc.`orthogonalize(Vector3dc v, Vector3d dest)`	Transform `this` vector so that it is orthogonal to the given vector `v`, normalize the result and store it into `dest`.
`Vector3d`	Vector3d.`orthogonalizeUnit(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3dc.`orthogonalizeUnit(Vector3dc v, Vector3d dest)`	Transform `this` vector so that it is orthogonal to the given unit vector `v`, normalize the result and store it into `dest`.
`Vector3d`	Matrix4d.`perspectiveInvOrigin(Vector3d dest)`
`Vector3d`	Matrix4dc.`perspectiveInvOrigin(Vector3d dest)`	Compute the eye/origin of the inverse of the perspective frustum transformation defined by `this` 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 `dest`.
`static void`	Matrix4d.`perspectiveOffCenterViewFromRectangle(Vector3d eye, Vector3d p, Vector3d x, Vector3d y, double nearFarDist, boolean zeroToOne, Matrix4d projDest, Matrix4d viewDest)`	Create a view and off-center perspective projection matrix from a given `eye` position, a given bottom left corner position `p` of the near plane rectangle and the extents of the near plane rectangle along its local `x` and `y` axes, and store the resulting matrices in `projDest` and `viewDest`.
`Vector3d`	Matrix4d.`perspectiveOrigin(Vector3d dest)`
`Vector3d`	Matrix4dc.`perspectiveOrigin(Vector3d origin)`	Compute the eye/origin of the perspective frustum transformation defined by `this` matrix, which can be a projection matrix or a combined modelview-projection matrix, and store the result in the given `origin`.
`Vector3d`	Matrix3d.`positiveX(Vector3d dir)`
`Vector3d`	Matrix3dc.`positiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4d.`positiveX(Vector3d dir)`
`Vector3d`	Matrix4dc.`positiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4x3d.`positiveX(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`positiveX(Vector3d dir)`	Obtain the direction of `+X` before the transformation represented by `this` matrix is applied.
`Vector3d`	Quaterniond.`positiveX(Vector3d dir)`
`Vector3d`	Quaterniondc.`positiveX(Vector3d dir)`	Obtain the direction of `+X` before the rotation transformation represented by `this` quaternion is applied.
`Vector3d`	Matrix3d.`positiveY(Vector3d dir)`
`Vector3d`	Matrix3dc.`positiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4d.`positiveY(Vector3d dir)`
`Vector3d`	Matrix4dc.`positiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4x3d.`positiveY(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`positiveY(Vector3d dir)`	Obtain the direction of `+Y` before the transformation represented by `this` matrix is applied.
`Vector3d`	Quaterniond.`positiveY(Vector3d dir)`
`Vector3d`	Quaterniondc.`positiveY(Vector3d dir)`	Obtain the direction of `+Y` before the rotation transformation represented by `this` quaternion is applied.
`Vector3d`	Matrix3d.`positiveZ(Vector3d dir)`
`Vector3d`	Matrix3dc.`positiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4d.`positiveZ(Vector3d dir)`
`Vector3d`	Matrix4dc.`positiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` matrix is applied.
`Vector3d`	Matrix4x3d.`positiveZ(Vector3d dir)`
`Vector3d`	Matrix4x3dc.`positiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the transformation represented by `this` matrix is applied.
`Vector3d`	Quaterniond.`positiveZ(Vector3d dir)`
`Vector3d`	Quaterniondc.`positiveZ(Vector3d dir)`	Obtain the direction of `+Z` before the rotation transformation represented by `this` quaternion is applied.
`Vector3d`	Matrix4d.`project(double x, double y, double z, int[] viewport, Vector3d winCoordsDest)`
`Vector3d`	Matrix4d.`project(Vector3dc position, int[] viewport, Vector3d dest)`
`Vector3d`	Matrix4dc.`project(double x, double y, double z, int[] viewport, Vector3d winCoordsDest)`	Project the given `(x, y, z)` position via `this` matrix using the specified viewport and store the resulting window coordinates in `winCoordsDest`.
`Vector3d`	Matrix4dc.`project(Vector3dc position, int[] viewport, Vector3d winCoordsDest)`	Project the given `position` via `this` matrix using the specified viewport and store the resulting window coordinates in `winCoordsDest`.
`Vector3d`	Vector3d.`reflect(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`reflect(Vector3dc normal, Vector3d dest)`
`Vector3d`	Vector3dc.`reflect(double x, double y, double z, Vector3d dest)`	Reflect this vector about the given normal vector and store the result in `dest`.
`Vector3d`	Vector3dc.`reflect(Vector3dc normal, Vector3d dest)`	Reflect this vector about the given normal vector and store the result in `dest`.
`Vector3d`	Vector3d.`rotate(Quaterniondc quat, Vector3d dest)`
`Vector3d`	Vector3dc.`rotate(Quaterniondc quat, Vector3d dest)`	Rotate this vector by the given quaternion `quat` and store the result in `dest`.
`Vector3d`	Vector3d.`rotateAxis(double angle, double aX, double aY, double aZ, Vector3d dest)`
`Vector3d`	Vector3dc.`rotateAxis(double angle, double aX, double aY, double aZ, Vector3d dest)`	Rotate this vector the specified radians around the given rotation axis and store the result into `dest`.
`Vector3d`	Vector3d.`rotateX(double angle, Vector3d dest)`
`Vector3d`	Vector3dc.`rotateX(double angle, Vector3d dest)`	Rotate this vector the specified radians around the X axis and store the result into `dest`.
`Matrix4d`	Matrix4d.`rotateXYZ(Vector3d angles)`	Apply rotation of `angles.x` radians about the X axis, followed by a rotation of `angles.y` radians about the Y axis and followed by a rotation of `angles.z` radians about the Z axis.
`Matrix4x3d`	Matrix4x3d.`rotateXYZ(Vector3d angles)`	Apply rotation of `angles.x` radians about the X axis, followed by a rotation of `angles.y` radians about the Y axis and followed by a rotation of `angles.z` radians about the Z axis.
`Vector3d`	Vector3d.`rotateY(double angle, Vector3d dest)`
`Vector3d`	Vector3dc.`rotateY(double angle, Vector3d dest)`	Rotate this vector the specified radians around the Y axis and store the result into `dest`.
`Matrix3d`	Matrix3d.`rotateYXZ(Vector3d angles)`	Apply rotation of `angles.y` radians about the Y axis, followed by a rotation of `angles.x` radians about the X axis and followed by a rotation of `angles.z` radians about the Z axis.
`Matrix4d`	Matrix4d.`rotateYXZ(Vector3d angles)`	Apply rotation of `angles.y` radians about the Y axis, followed by a rotation of `angles.x` radians about the X axis and followed by a rotation of `angles.z` radians about the Z axis.
`Matrix4x3d`	Matrix4x3d.`rotateYXZ(Vector3d angles)`	Apply rotation of `angles.y` radians about the Y axis, followed by a rotation of `angles.x` radians about the X axis and followed by a rotation of `angles.z` radians about the Z axis.
`Vector3d`	Vector3d.`rotateZ(double angle, Vector3d dest)`
`Vector3d`	Vector3dc.`rotateZ(double angle, Vector3d dest)`	Rotate this vector the specified radians around the Z axis and store the result into `dest`.
`Matrix4d`	Matrix4d.`rotateZYX(Vector3d angles)`	Apply rotation of `angles.z` radians about the Z axis, followed by a rotation of `angles.y` radians about the Y axis and followed by a rotation of `angles.x` radians about the X axis.
`Matrix4x3d`	Matrix4x3d.`rotateZYX(Vector3d angles)`	Apply rotation of `angles.z` radians about the Z axis, followed by a rotation of `angles.y` radians about the Y axis and followed by a rotation of `angles.x` radians about the X axis.
`Vector3d`	Vector3d.`round(Vector3d dest)`
`Vector3d`	Vector3dc.`round(Vector3d dest)`	Compute for each component of this vector the closest double that is equal to a mathematical integer, with ties rounding to positive infinity and store the result in `dest`.
`Vector3d`	Vector3d.`smoothStep(Vector3dc v, double t, Vector3d dest)`
`Vector3d`	Vector3dc.`smoothStep(Vector3dc v, double t, Vector3d dest)`	Compute a smooth-step (i.e.
`Vector3d`	Vector3d.`sub(double x, double y, double z, Vector3d dest)`
`Vector3d`	Vector3d.`sub(Vector3dc v, Vector3d dest)`
`Vector3d`	Vector3d.`sub(Vector3fc v, Vector3d dest)`
`Vector3d`	Vector3dc.`sub(double x, double y, double z, Vector3d dest)`	Subtract `(x, y, z)` from this vector and store the result in `dest`.
`Vector3d`	Vector3dc.`sub(Vector3dc v, Vector3d dest)`	Subtract the supplied vector from this one and store the result in `dest`.
`Vector3d`	Vector3dc.`sub(Vector3fc v, Vector3d dest)`	Subtract the supplied vector from this one and store the result in `dest`.
`static boolean`	Intersectiond.`testObOb(Vector3d b0c, Vector3d b0uX, Vector3d b0uY, Vector3d b0uZ, Vector3d b0hs, Vector3d b1c, Vector3d b1uX, Vector3d b1uY, Vector3d b1uZ, Vector3d b1hs)`	Test whether two oriented boxes given via their center position, orientation and half-size, intersect.
`Vector3d`	AxisAngle4d.`transform(Vector3d v)`	Transform the given vector by the rotation transformation described by this `AxisAngle4d`.
`Vector3d`	AxisAngle4d.`transform(Vector3dc v, Vector3d dest)`	Transform the given vector by the rotation transformation described by this `AxisAngle4d` and store the result in `dest`.
`Vector3d`	Matrix3d.`transform(double x, double y, double z, Vector3d dest)`
`Vector3d`	Matrix3d.`transform(Vector3d v)`
`Vector3d`	Matrix3d.`transform(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix3dc.`transform(double x, double y, double z, Vector3d dest)`	Transform the vector `(x, y, z)` by this matrix and store the result in `dest`.
`Vector3d`	Matrix3dc.`transform(Vector3d v)`	Transform the given vector by this matrix.
`Vector3d`	Matrix3dc.`transform(Vector3dc v, Vector3d dest)`	Transform the given vector by this matrix and store the result in `dest`.
`Vector3d`	Matrix3x2d.`transform(double x, double y, double z, Vector3d dest)`	Transform/multiply the given vector `(x, y, z)` by this matrix and store the result in `dest`.
`Vector3d`	Matrix3x2d.`transform(Vector3d v)`	Transform/multiply the given vector by this matrix by assuming a third row in this matrix of `(0, 0, 1)` and store the result in that vector.
`Vector3d`	Matrix3x2d.`transform(Vector3dc v, Vector3d dest)`	Transform/multiply the given vector by this matrix by assuming a third row in this matrix of `(0, 0, 1)` and store the result in `dest`.
`Vector3d`	Matrix3x2dc.`transform(double x, double y, double z, Vector3d dest)`	Transform/multiply the given vector `(x, y, z)` by this matrix and store the result in `dest`.
`Vector3d`	Matrix3x2dc.`transform(Vector3d v)`	Transform/multiply the given vector by this matrix by assuming a third row in this matrix of `(0, 0, 1)` and store the result in that vector.
`Vector3d`	Matrix3x2dc.`transform(Vector3dc v, Vector3d dest)`	Transform/multiply the given vector by this matrix and store the result in `dest`.
`Vector3d`	Quaterniond.`transform(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaterniond.`transform(Vector3d vec)`
`Vector3d`	Quaterniond.`transform(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaterniondc.`transform(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this quaternion and store the result in `dest`.
`Vector3d`	Quaterniondc.`transform(Vector3d vec)`	Transform the given vector by this quaternion.
`Vector3d`	Quaterniondc.`transform(Vector3dc vec, Vector3d dest)`	Transform the given vector by this quaternion and store the result in `dest`.
`Vector3d`	Quaternionf.`transform(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaternionf.`transform(float x, float y, float z, Vector3d dest)`
`Vector3d`	Quaternionf.`transform(Vector3d vec)`
`Vector3d`	Quaternionf.`transform(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaternionfc.`transform(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transform(float x, float y, float z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transform(Vector3d vec)`	Transform the given vector by this quaternion.
`Vector3d`	Quaternionfc.`transform(Vector3dc vec, Vector3d dest)`	Transform the given vector by this quaternion and store the result in `dest`.
`Matrix4d`	Matrix4d.`transformAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vector3d outMin, Vector3d outMax)`
`Matrix4d`	Matrix4d.`transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d outMax)`
`Matrix4d`	Matrix4dc.`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 `(minX, minY, minZ)` and maximum corner `(maxX, maxY, maxZ)` by `this` `affine` matrix and compute the axis-aligned box of the result whose minimum corner is stored in `outMin` and maximum corner stored in `outMax`.
`Matrix4d`	Matrix4dc.`transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d outMax)`	Transform the axis-aligned box given as the minimum corner `min` and maximum corner `max` by `this` `affine` matrix and compute the axis-aligned box of the result whose minimum corner is stored in `outMin` and maximum corner stored in `outMax`.
`Matrix4x3d`	Matrix4x3d.`transformAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vector3d outMin, Vector3d outMax)`
`Matrix4x3d`	Matrix4x3d.`transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d outMax)`
`Matrix4x3d`	Matrix4x3dc.`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 `(minX, minY, minZ)` and maximum corner `(maxX, maxY, maxZ)` by `this` matrix and compute the axis-aligned box of the result whose minimum corner is stored in `outMin` and maximum corner stored in `outMax`.
`Matrix4x3d`	Matrix4x3dc.`transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d outMax)`	Transform the axis-aligned box given as the minimum corner `min` and maximum corner `max` by `this` matrix and compute the axis-aligned box of the result whose minimum corner is stored in `outMin` and maximum corner stored in `outMax`.
`Vector3d`	Matrix4d.`transformDirection(double x, double y, double z, Vector3d dest)`
`Vector3d`	Matrix4d.`transformDirection(Vector3d dest)`
`Vector3d`	Matrix4d.`transformDirection(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix4dc.`transformDirection(double x, double y, double z, Vector3d dest)`	Transform/multiply the 3D-vector `(x, y, z)`, as if it was a 4D-vector with w=0, by this matrix and store the result in `dest`.
`Vector3d`	Matrix4dc.`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 that vector.
`Vector3d`	Matrix4dc.`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 `dest`.
`Vector3d`	Matrix4x3d.`transformDirection(Vector3d v)`
`Vector3d`	Matrix4x3d.`transformDirection(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix4x3dc.`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 that vector.
`Vector3d`	Matrix4x3dc.`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 `dest`.
`Vector3d`	Quaterniond.`transformInverse(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaterniond.`transformInverse(Vector3d vec)`
`Vector3d`	Quaterniond.`transformInverse(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaterniondc.`transformInverse(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this quaternion and store the result in `dest`.
`Vector3d`	Quaterniondc.`transformInverse(Vector3d vec)`	Transform the given vector by the inverse of this quaternion.
`Vector3d`	Quaterniondc.`transformInverse(Vector3dc vec, Vector3d dest)`	Transform the given vector by the inverse of this quaternion and store the result in `dest`.
`Vector3d`	Quaternionf.`transformInverse(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformInverse(float x, float y, float z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformInverse(Vector3d vec)`
`Vector3d`	Quaternionf.`transformInverse(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaternionfc.`transformInverse(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformInverse(float x, float y, float z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformInverse(Vector3d vec)`	Transform the given vector by the inverse of this quaternion.
`Vector3d`	Quaternionfc.`transformInverse(Vector3dc vec, Vector3d dest)`	Transform the given vector by the inverse of this quaternion and store the result in `dest`.
`Vector3d`	Quaterniond.`transformInverseUnit(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaterniond.`transformInverseUnit(Vector3d vec)`
`Vector3d`	Quaterniond.`transformInverseUnit(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaterniondc.`transformInverseUnit(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this unit quaternion and store the result in `dest`.
`Vector3d`	Quaterniondc.`transformInverseUnit(Vector3d vec)`	Transform the given vector by the inverse of this unit quaternion.
`Vector3d`	Quaterniondc.`transformInverseUnit(Vector3dc vec, Vector3d dest)`	Transform the given vector by the inverse of this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionf.`transformInverseUnit(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformInverseUnit(float x, float y, float z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformInverseUnit(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaternionfc.`transformInverseUnit(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformInverseUnit(float x, float y, float z, Vector3d dest)`	Transform the given vector `(x, y, z)` by the inverse of this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformInverseUnit(Vector3dc vec, Vector3d dest)`	Transform the given vector by the inverse of this unit quaternion and store the result in `dest`.
`Vector3d`	Matrix4d.`transformPosition(double x, double y, double z, Vector3d dest)`
`Vector3d`	Matrix4d.`transformPosition(Vector3d dest)`
`Vector3d`	Matrix4d.`transformPosition(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix4dc.`transformPosition(double x, double y, double z, Vector3d dest)`	Transform/multiply the 3D-vector `(x, y, z)`, as if it was a 4D-vector with w=1, by this matrix and store the result in `dest`.
`Vector3d`	Matrix4dc.`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 that vector.
`Vector3d`	Matrix4dc.`transformPosition(Vector3dc v, 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 `dest`.
`Vector3d`	Matrix4x3d.`transformPosition(Vector3d v)`
`Vector3d`	Matrix4x3d.`transformPosition(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix4x3dc.`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 that vector.
`Vector3d`	Matrix4x3dc.`transformPosition(Vector3dc v, 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 `dest`.
`Vector3d`	Quaterniond.`transformPositiveX(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformPositiveX(Vector3d dest)`	Transform the vector `(1, 0, 0)` by this quaternion.
`Vector3d`	Quaternionf.`transformPositiveX(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformPositiveX(Vector3d dest)`	Transform the vector `(1, 0, 0)` by this quaternion.
`Vector3d`	Quaterniond.`transformPositiveY(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformPositiveY(Vector3d dest)`	Transform the vector `(0, 1, 0)` by this quaternion.
`Vector3d`	Quaternionf.`transformPositiveY(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformPositiveY(Vector3d dest)`	Transform the vector `(0, 1, 0)` by this quaternion.
`Vector3d`	Quaterniond.`transformPositiveZ(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformPositiveZ(Vector3d dest)`	Transform the vector `(0, 0, 1)` by this quaternion.
`Vector3d`	Quaternionf.`transformPositiveZ(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformPositiveZ(Vector3d dest)`	Transform the vector `(0, 0, 1)` by this quaternion.
`Vector3d`	Matrix4d.`transformProject(double x, double y, double z, double w, Vector3d dest)`
`Vector3d`	Matrix4d.`transformProject(double x, double y, double z, Vector3d dest)`
`Vector3d`	Matrix4d.`transformProject(Vector3d v)`
`Vector3d`	Matrix4d.`transformProject(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix4d.`transformProject(Vector4dc v, Vector3d dest)`
`Vector3d`	Matrix4dc.`transformProject(double x, double y, double z, double w, Vector3d dest)`	Transform/multiply the vector `(x, y, z, w)` by this matrix, perform perspective divide and store `(x, y, z)` of the result in `dest`.
`Vector3d`	Matrix4dc.`transformProject(double x, double y, double z, Vector3d dest)`	Transform/multiply the vector `(x, y, z)` by this matrix, perform perspective divide and store the result in `dest`.
`Vector3d`	Matrix4dc.`transformProject(Vector3d v)`	Transform/multiply the given vector by this matrix, perform perspective divide and store the result in that vector.
`Vector3d`	Matrix4dc.`transformProject(Vector3dc v, Vector3d dest)`	Transform/multiply the given vector by this matrix, perform perspective divide and store the result in `dest`.
`Vector3d`	Matrix4dc.`transformProject(Vector4dc v, Vector3d dest)`	Transform/multiply the given vector by this matrix, perform perspective divide and store the `x`, `y` and `z` components of the result in `dest`.
`Vector3d`	Matrix3d.`transformTranspose(double x, double y, double z, Vector3d dest)`
`Vector3d`	Matrix3d.`transformTranspose(Vector3d v)`
`Vector3d`	Matrix3d.`transformTranspose(Vector3dc v, Vector3d dest)`
`Vector3d`	Matrix3dc.`transformTranspose(double x, double y, double z, Vector3d dest)`	Transform the vector `(x, y, z)` by the transpose of this matrix and store the result in `dest`.
`Vector3d`	Matrix3dc.`transformTranspose(Vector3d v)`	Transform the given vector by the transpose of this matrix.
`Vector3d`	Matrix3dc.`transformTranspose(Vector3dc v, Vector3d dest)`	Transform the given vector by the transpose of this matrix and store the result in `dest`.
`Vector3d`	Quaterniond.`transformUnit(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaterniond.`transformUnit(Vector3d vec)`
`Vector3d`	Quaterniond.`transformUnit(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaterniondc.`transformUnit(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this unit quaternion and store the result in `dest`.
`Vector3d`	Quaterniondc.`transformUnit(Vector3d vec)`	Transform the given vector by this unit quaternion.
`Vector3d`	Quaterniondc.`transformUnit(Vector3dc vec, Vector3d dest)`	Transform the given vector by this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionf.`transformUnit(double x, double y, double z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformUnit(float x, float y, float z, Vector3d dest)`
`Vector3d`	Quaternionf.`transformUnit(Vector3dc vec, Vector3d dest)`
`Vector3d`	Quaternionfc.`transformUnit(double x, double y, double z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformUnit(float x, float y, float z, Vector3d dest)`	Transform the given vector `(x, y, z)` by this unit quaternion and store the result in `dest`.
`Vector3d`	Quaternionfc.`transformUnit(Vector3dc vec, Vector3d dest)`	Transform the given vector by this unit quaternion and store the result in `dest`.
`Vector3d`	Quaterniond.`transformUnitPositiveX(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformUnitPositiveX(Vector3d dest)`	Transform the vector `(1, 0, 0)` by this unit quaternion.
`Vector3d`	Quaternionf.`transformUnitPositiveX(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformUnitPositiveX(Vector3d dest)`	Transform the vector `(1, 0, 0)` by this unit quaternion.
`Vector3d`	Quaterniond.`transformUnitPositiveY(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformUnitPositiveY(Vector3d dest)`	Transform the vector `(0, 1, 0)` by this unit quaternion.
`Vector3d`	Quaternionf.`transformUnitPositiveY(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformUnitPositiveY(Vector3d dest)`	Transform the vector `(0, 1, 0)` by this unit quaternion.
`Vector3d`	Quaterniond.`transformUnitPositiveZ(Vector3d dest)`
`Vector3d`	Quaterniondc.`transformUnitPositiveZ(Vector3d dest)`	Transform the vector `(0, 0, 1)` by this unit quaternion.
`Vector3d`	Quaternionf.`transformUnitPositiveZ(Vector3d dest)`
`Vector3d`	Quaternionfc.`transformUnitPositiveZ(Vector3d dest)`	Transform the vector `(0, 0, 1)` by this unit quaternion.
`Vector3d`	Matrix4d.`unproject(double winX, double winY, double winZ, int[] viewport, Vector3d dest)`
`Vector3d`	Matrix4d.`unproject(Vector3dc winCoords, int[] viewport, Vector3d dest)`
`Vector3d`	Matrix4dc.`unproject(double winX, double winY, double winZ, int[] viewport, Vector3d dest)`	Unproject the given window coordinates `(winX, winY, winZ)` by `this` matrix using the specified viewport.
`Vector3d`	Matrix4dc.`unproject(Vector3dc winCoords, int[] viewport, Vector3d dest)`	Unproject the given window coordinates `winCoords` by `this` matrix using the specified viewport.
`Vector3d`	Matrix4d.`unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector3d dest)`
`Vector3d`	Matrix4d.`unprojectInv(Vector3dc winCoords, int[] viewport, Vector3d dest)`
`Vector3d`	Matrix4dc.`unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector3d dest)`	Unproject the given window coordinates `(winX, winY, winZ)` by `this` matrix using the specified viewport.
`Vector3d`	Matrix4dc.`unprojectInv(Vector3dc winCoords, int[] viewport, Vector3d dest)`	Unproject the given window coordinates `winCoords` by `this` matrix using the specified viewport.
`Matrix4d`	Matrix4d.`unprojectInvRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest)`
`Matrix4d`	Matrix4d.`unprojectInvRay(Vector2dc winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest)`
`Matrix4d`	Matrix4dc.`unprojectInvRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest)`	Unproject the given 2D window coordinates `(winX, winY)` by `this` matrix using the specified viewport and compute the origin and the direction of the resulting ray which starts at NDC `z = -1.0` and goes through NDC `z = +1.0`.
`Matrix4d`	Matrix4dc.`unprojectInvRay(Vector2dc winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest)`	Unproject the given window coordinates `winCoords` by `this` matrix using the specified viewport and compute the origin and the direction of the resulting ray which starts at NDC `z = -1.0` and goes through NDC `z = +1.0`.
`Matrix4d`	Matrix4d.`unprojectRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest)`
`Matrix4d`	Matrix4d.`unprojectRay(Vector2dc winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest)`
`Matrix4d`	Matrix4dc.`unprojectRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest)`	Unproject the given 2D window coordinates `(winX, winY)` by `this` matrix using the specified viewport and compute the origin and the direction of the resulting ray which starts at NDC `z = -1.0` and goes through NDC `z = +1.0`.
`Matrix4d`	Matrix4dc.`unprojectRay(Vector2dc winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest)`	Unproject the given 2D window coordinates `winCoords` by `this` matrix using the specified viewport and compute the origin and the direction of the resulting ray which starts at NDC `z = -1.0` and goes through NDC `z = +1.0`.

Uses of Classorg.joml.Vector3d

Uses of Vector3d in org.joml

Uses of Class
org.joml.Vector3d