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