Package org.joml

Interface Vector3fc

• All Known Implementing Classes:
`Vector3f`

`public interface Vector3fc`
Interface to a read-only view of a 3-dimensional vector of single-precision floats.
Author:
Kai Burjack
• Method Summary

All Methods
Modifier and Type Method Description
`Vector3f` `absolute​(Vector3f dest)`
Compute the absolute values of the individual components of `this` and store the result in `dest`.
`Vector3f` ```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` ```add​(Vector3fc v, Vector3f dest)```
Add the supplied vector to this one and store the result in `dest`.
`float` `angle​(Vector3fc v)`
Return the angle between this vector and the supplied vector.
`float` `angleCos​(Vector3fc v)`
Return the cosine of the angle between this vector and the supplied vector.
`float` ```angleSigned​(float x, float y, float z, float nx, float ny, float nz)```
Return the signed angle between this vector and the supplied vector with respect to the plane with the given normal vector `(nx, ny, nz)`.
`float` ```angleSigned​(Vector3fc v, Vector3fc n)```
Return the signed angle between this vector and the supplied vector with respect to the plane with the given normal vector `n`.
`Vector3f` `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` ```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` ```cross​(Vector3fc v, Vector3f dest)```
Compute the cross product of this vector and `v` and store the result in `dest`.
`float` ```distance​(float x, float y, float z)```
Return the distance between `this` vector and `(x, y, z)`.
`float` `distance​(Vector3fc v)`
Return the distance between this Vector and `v`.
`float` ```distanceSquared​(float x, float y, float z)```
Return the square of the distance between `this` vector and `(x, y, z)`.
`float` `distanceSquared​(Vector3fc v)`
Return the square of the distance between this vector and `v`.
`Vector3f` ```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` ```div​(float scalar, Vector3f dest)```
Divide all components of this `Vector3f` by the given scalar value and store the result in `dest`.
`Vector3f` ```div​(Vector3fc v, Vector3f dest)```
Divide this Vector3f component-wise by another Vector3f and store the result in `dest`.
`float` ```dot​(float x, float y, float z)```
Return the dot product of this vector and the vector `(x, y, z)`.
`float` `dot​(Vector3fc v)`
Return the dot product of this vector and the supplied vector.
`boolean` ```equals​(float x, float y, float z)```
Compare the vector components of `this` vector with the given `(x, y, z)` and return whether all of them are equal.
`boolean` ```equals​(Vector3fc v, float delta)```
Compare the vector components of `this` vector with the given vector using the given `delta` and return whether all of them are equal within a maximum difference of `delta`.
`Vector3f` `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` ```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` ```fma​(Vector3fc a, Vector3fc b, Vector3f dest)```
Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`float` `get​(int component)`
Get the value of the specified component of this vector.
`java.nio.ByteBuffer` ```get​(int index, java.nio.ByteBuffer buffer)```
Store this vector into the supplied `ByteBuffer` starting at the specified absolute buffer position/index.
`java.nio.FloatBuffer` ```get​(int index, java.nio.FloatBuffer buffer)```
Store this vector into the supplied `FloatBuffer` starting at the specified absolute buffer position/index.
`Vector3i` ```get​(int mode, Vector3i dest)```
Set the components of the given vector `dest` to those of `this` vector using the given `RoundingMode`.
`java.nio.ByteBuffer` `get​(java.nio.ByteBuffer buffer)`
Store this vector into the supplied `ByteBuffer` at the current buffer `position`.
`java.nio.FloatBuffer` `get​(java.nio.FloatBuffer buffer)`
Store this vector into the supplied `FloatBuffer` at the current buffer `position`.
`Vector3d` `get​(Vector3d dest)`
Set the components of the given vector `dest` to those of `this` vector.
`Vector3f` `get​(Vector3f dest)`
Set the components of the given vector `dest` to those of `this` vector.
`Vector3fc` `getToAddress​(long address)`
Store this vector at the given off-heap memory address.
`Vector3f` ```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` ```half​(Vector3fc other, Vector3f dest)```
Compute the half vector between this and the other vector and store the result in `dest`.
`Vector3f` ```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`.
`boolean` `isFinite()`
Determine whether all components are finite floating-point values, that is, they are not `NaN` and not `infinity`.
`float` `length()`
Return the length of this vector.
`float` `lengthSquared()`
Return the length squared of this vector.
`Vector3f` ```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` ```max​(Vector3fc v, Vector3f dest)```
Set the components of `dest` to be the component-wise maximum of this and the other vector.
`int` `maxComponent()`
Determine the component with the biggest absolute value.
`Vector3f` ```min​(Vector3fc v, Vector3f dest)```
Set the components of `dest` to be the component-wise minimum of this and the other vector.
`int` `minComponent()`
Determine the component with the smallest (towards zero) absolute value.
`Vector3f` ```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` ```mul​(float scalar, Vector3f dest)```
Multiply all components of this `Vector3f` by the given scalar value and store the result in `dest`.
`Vector3f` ```mul​(Matrix3dc mat, Vector3f dest)```
Multiply the given matrix with this Vector3f and store the result in `dest`.
`Vector3f` ```mul​(Matrix3fc mat, Vector3f dest)```
Multiply the given matrix with this Vector3f and store the result in `dest`.
`Vector3f` ```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` ```mul​(Vector3fc v, Vector3f dest)```
Multiply this Vector3f component-wise by another Vector3f and store the result in `dest`.
`Vector3f` ```mulAdd​(float a, Vector3fc b, Vector3f dest)```
Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
`Vector3f` ```mulAdd​(Vector3fc a, Vector3fc b, Vector3f dest)```
Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
`Vector3f` ```mulDirection​(Matrix4dc mat, Vector3f dest)```
Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3f` ```mulDirection​(Matrix4fc mat, Vector3f dest)```
Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3f` ```mulDirection​(Matrix4x3fc mat, Vector3f dest)```
Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.
`Vector3f` ```mulPosition​(Matrix4fc mat, Vector3f dest)```
Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3f` ```mulPosition​(Matrix4x3fc mat, Vector3f dest)```
Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.
`float` ```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` ```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` ```mulProject​(Matrix4fc mat, Vector3f dest)```
Multiply the given matrix `mat` with this Vector3f, perform perspective division and store the result in `dest`.
`Vector3f` ```mulTranspose​(Matrix3fc mat, Vector3f dest)```
Multiply the transpose of the given matrix with this Vector3f and store the result in `dest`.
`Vector3f` ```mulTransposeDirection​(Matrix4fc mat, Vector3f dest)```
Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3f` ```mulTransposePosition​(Matrix4fc mat, Vector3f dest)```
Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.
`Vector3f` `negate​(Vector3f dest)`
Negate this vector and store the result in `dest`.
`Vector3f` ```normalize​(float length, Vector3f dest)```
Scale this vector to have the given length and store the result in `dest`.
`Vector3f` `normalize​(Vector3f dest)`
Normalize this vector and store the result in `dest`.
`Vector3f` ```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` ```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`.
`Vector3f` ```reflect​(float x, float y, float z, Vector3f dest)```
Reflect this vector about the given normal vector and store the result in `dest`.
`Vector3f` ```reflect​(Vector3fc normal, Vector3f dest)```
Reflect this vector about the given `normal` vector and store the result in `dest`.
`Vector3f` ```rotate​(Quaternionfc quat, Vector3f dest)```
Rotate this vector by the given quaternion `quat` and store the result in `dest`.
`Vector3f` ```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` ```rotateX​(float angle, Vector3f dest)```
Rotate this vector the specified radians around the X axis and store the result into `dest`.
`Vector3f` ```rotateY​(float angle, Vector3f dest)```
Rotate this vector the specified radians around the Y axis and store the result into `dest`.
`Vector3f` ```rotateZ​(float angle, Vector3f dest)```
Rotate this vector the specified radians around the Z axis and store the result into `dest`.
`Quaternionf` ```rotationTo​(float toDirX, float toDirY, float toDirZ, Quaternionf dest)```
Compute the quaternion representing a rotation of `this` vector to point along `(toDirX, toDirY, toDirZ)` and store the result in `dest`.
`Quaternionf` ```rotationTo​(Vector3fc toDir, Quaternionf dest)```
Compute the quaternion representing a rotation of `this` vector to point along `toDir` and store the result in `dest`.
`Vector3f` `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`.
`Vector3f` ```smoothStep​(Vector3fc v, float t, Vector3f dest)```
Compute a smooth-step (i.e.
`Vector3f` ```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` ```sub​(Vector3fc v, Vector3f dest)```
Subtract the supplied vector from this one and store the result in `dest`.
`float` `x()`
`float` `y()`
`float` `z()`
• Method Detail

• x

`float x()`
Returns:
the value of the x component
• y

`float y()`
Returns:
the value of the y component
• z

`float z()`
Returns:
the value of the z component
• get

`java.nio.FloatBuffer get​(java.nio.FloatBuffer buffer)`
Store this vector into the supplied `FloatBuffer` at the current buffer `position`.

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

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

Parameters:
`buffer` - will receive the values of this vector in `x, y, z` order
Returns:
the passed in buffer
`get(int, FloatBuffer)`, `get(int, FloatBuffer)`
• get

```java.nio.FloatBuffer get​(int index,
java.nio.FloatBuffer buffer)```
Store this vector into the supplied `FloatBuffer` starting at the specified absolute buffer position/index.

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

Parameters:
`index` - the absolute position into the FloatBuffer
`buffer` - will receive the values of this vector in `x, y, z` order
Returns:
the passed in buffer
• get

`java.nio.ByteBuffer get​(java.nio.ByteBuffer buffer)`
Store this vector into the supplied `ByteBuffer` at the current buffer `position`.

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

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

Parameters:
`buffer` - will receive the values of this vector in `x, y, z` order
Returns:
the passed in buffer
`get(int, ByteBuffer)`, `get(int, ByteBuffer)`
• get

```java.nio.ByteBuffer get​(int index,
java.nio.ByteBuffer buffer)```
Store this vector into the supplied `ByteBuffer` starting at the specified absolute buffer position/index.

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

Parameters:
`index` - the absolute position into the ByteBuffer
`buffer` - will receive the values of this vector in `x, y, z` order
Returns:
the passed in buffer

`Vector3fc getToAddress​(long address)`
Store this vector at the given off-heap memory address.

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

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

Parameters:
`address` - the off-heap address where to store this vector
Returns:
this
• sub

```Vector3f sub​(Vector3fc v,
Vector3f dest)```
Subtract the supplied vector from this one and store the result in `dest`.
Parameters:
`v` - the vector to subtract
`dest` - will hold the result
Returns:
dest
• sub

```Vector3f 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`.
Parameters:
`x` - the x component to subtract
`y` - the y component to subtract
`z` - the z component to subtract
`dest` - will hold the result
Returns:
dest

```Vector3f add​(Vector3fc v,
Vector3f dest)```
Add the supplied vector to this one and store the result in `dest`.
Parameters:
`v` - the vector to add
`dest` - will hold the result
Returns:
dest

```Vector3f 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`.
Parameters:
`x` - the x component to add
`y` - the y component to add
`z` - the z component to add
`dest` - will hold the result
Returns:
dest
• fma

```Vector3f fma​(Vector3fc a,
Vector3fc b,
Vector3f dest)```
Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
Parameters:
`a` - the first multiplicand
`b` - the second multiplicand
`dest` - will hold the result
Returns:
dest
• fma

```Vector3f fma​(float a,
Vector3fc b,
Vector3f dest)```
Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
Parameters:
`a` - the first multiplicand
`b` - the second multiplicand
`dest` - will hold the result
Returns:
dest

```Vector3f mulAdd​(Vector3fc a,
Vector3fc b,
Vector3f dest)```
Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
Parameters:
`a` - the multiplicand
`b` - the addend
`dest` - will hold the result
Returns:
dest

```Vector3f mulAdd​(float a,
Vector3fc b,
Vector3f dest)```
Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
Parameters:
`a` - the multiplicand
`b` - the addend
`dest` - will hold the result
Returns:
dest
• mul

```Vector3f mul​(Vector3fc v,
Vector3f dest)```
Multiply this Vector3f component-wise by another Vector3f and store the result in `dest`.
Parameters:
`v` - the vector to multiply by
`dest` - will hold the result
Returns:
dest
• div

```Vector3f div​(Vector3fc v,
Vector3f dest)```
Divide this Vector3f component-wise by another Vector3f and store the result in `dest`.
Parameters:
`v` - the vector to divide by
`dest` - will hold the result
Returns:
dest
• mulProject

```Vector3f mulProject​(Matrix4fc mat,
Vector3f dest)```
Multiply the given matrix `mat` with this Vector3f, perform perspective division and store the result in `dest`.

This method uses `w=1.0` as the fourth vector component.

Parameters:
`mat` - the matrix to multiply this vector by
`dest` - will hold the result
Returns:
dest
• mulProject

```Vector3f mulProject​(Matrix4fc mat,
float w,
Vector3f dest)```
Multiply the given matrix `mat` with this Vector3f, perform perspective division and store the result in `dest`.

This method uses the given `w` as the fourth vector component.

Parameters:
`mat` - the matrix to multiply this vector by
`w` - the w component to use
`dest` - will hold the result
Returns:
dest
• mul

```Vector3f mul​(Matrix3fc mat,
Vector3f dest)```
Multiply the given matrix with this Vector3f and store the result in `dest`.
Parameters:
`mat` - the matrix
`dest` - will hold the result
Returns:
dest
• mul

```Vector3f mul​(Matrix3dc mat,
Vector3f dest)```
Multiply the given matrix with this Vector3f and store the result in `dest`.
Parameters:
`mat` - the matrix
`dest` - will hold the result
Returns:
dest
• mul

```Vector3f 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`.
Parameters:
`mat` - the matrix to multiply this vector by
`dest` - will hold the result
Returns:
dest
• mulTranspose

```Vector3f mulTranspose​(Matrix3fc mat,
Vector3f dest)```
Multiply the transpose of the given matrix with this Vector3f and store the result in `dest`.
Parameters:
`mat` - the matrix
`dest` - will hold the result
Returns:
dest
• mulPosition

```Vector3f mulPosition​(Matrix4fc mat,
Vector3f dest)```
Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.

This method assumes the `w` component of `this` to be `1.0`.

Parameters:
`mat` - the matrix to multiply this vector by
`dest` - will hold the result
Returns:
dest
• mulPosition

```Vector3f mulPosition​(Matrix4x3fc mat,
Vector3f dest)```
Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.

This method assumes the `w` component of `this` to be `1.0`.

Parameters:
`mat` - the matrix to multiply this vector by
`dest` - will hold the result
Returns:
dest
• mulTransposePosition

```Vector3f mulTransposePosition​(Matrix4fc mat,
Vector3f dest)```
Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.

This method assumes the `w` component of `this` to be `1.0`.

Parameters:
`mat` - the matrix whose transpose to multiply this vector by
`dest` - will hold the result
Returns:
dest
• mulPositionW

```float 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.

This method assumes the `w` component of `this` to be `1.0`.

Parameters:
`mat` - the matrix to multiply this vector by
`dest` - will hold the `(x, y, z)` components of the resulting vector
Returns:
the w component of the resulting 4D vector after multiplication
• mulDirection

```Vector3f mulDirection​(Matrix4dc mat,
Vector3f dest)```
Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.

This method assumes the `w` component of `this` to be `0.0`.

Parameters:
`mat` - the matrix to multiply this vector by
`dest` - will hold the result
Returns:
dest
• mulDirection

```Vector3f mulDirection​(Matrix4fc mat,
Vector3f dest)```
Multiply the given 4x4 matrix `mat` with `this` and store the result in `dest`.

This method assumes the `w` component of `this` to be `0.0`.

Parameters:
`mat` - the matrix to multiply this vector by
`dest` - will hold the result
Returns:
dest
• mulDirection

```Vector3f mulDirection​(Matrix4x3fc mat,
Vector3f dest)```
Multiply the given 4x3 matrix `mat` with `this` and store the result in `dest`.

This method assumes the `w` component of `this` to be `0.0`.

Parameters:
`mat` - the matrix to multiply this vector by
`dest` - will hold the result
Returns:
dest
• mulTransposeDirection

```Vector3f mulTransposeDirection​(Matrix4fc mat,
Vector3f dest)```
Multiply the transpose of the given 4x4 matrix `mat` with `this` and store the result in `dest`.

This method assumes the `w` component of `this` to be `0.0`.

Parameters:
`mat` - the matrix whose transpose to multiply this vector by
`dest` - will hold the result
Returns:
dest
• mul

```Vector3f mul​(float scalar,
Vector3f dest)```
Multiply all components of this `Vector3f` by the given scalar value and store the result in `dest`.
Parameters:
`scalar` - the scalar to multiply this vector by
`dest` - will hold the result
Returns:
dest
• mul

```Vector3f 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`.
Parameters:
`x` - the x component to multiply this vector by
`y` - the y component to multiply this vector by
`z` - the z component to multiply this vector by
`dest` - will hold the result
Returns:
dest
• div

```Vector3f div​(float scalar,
Vector3f dest)```
Divide all components of this `Vector3f` by the given scalar value and store the result in `dest`.
Parameters:
`scalar` - the scalar to divide by
`dest` - will hold the result
Returns:
dest
• div

```Vector3f 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`.
Parameters:
`x` - the x component to divide this vector by
`y` - the y component to divide this vector by
`z` - the z component to divide this vector by
`dest` - will hold the result
Returns:
dest
• rotate

```Vector3f rotate​(Quaternionfc quat,
Vector3f dest)```
Rotate this vector by the given quaternion `quat` and store the result in `dest`.
Parameters:
`quat` - the quaternion to rotate this vector
`dest` - will hold the result
Returns:
dest
`Quaternionfc.transform(Vector3f)`
• rotationTo

```Quaternionf rotationTo​(Vector3fc toDir,
Quaternionf dest)```
Compute the quaternion representing a rotation of `this` vector to point along `toDir` and store the result in `dest`.

Because there can be multiple possible rotations, this method chooses the one with the shortest arc.

Parameters:
`toDir` - the destination direction
`dest` - will hold the result
Returns:
dest
`Quaternionf.rotationTo(Vector3fc, Vector3fc)`
• rotationTo

```Quaternionf rotationTo​(float toDirX,
float toDirY,
float toDirZ,
Quaternionf dest)```
Compute the quaternion representing a rotation of `this` vector to point along `(toDirX, toDirY, toDirZ)` and store the result in `dest`.

Because there can be multiple possible rotations, this method chooses the one with the shortest arc.

Parameters:
`toDirX` - the x coordinate of the destination direction
`toDirY` - the y coordinate of the destination direction
`toDirZ` - the z coordinate of the destination direction
`dest` - will hold the result
Returns:
dest
`Quaternionf.rotationTo(float, float, float, float, float, float)`
• rotateAxis

```Vector3f 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`.
Parameters:
`angle` - the angle in radians
`aX` - the x component of the rotation axis
`aY` - the y component of the rotation axis
`aZ` - the z component of the rotation axis
`dest` - will hold the result
Returns:
dest
• rotateX

```Vector3f rotateX​(float angle,
Vector3f dest)```
Rotate this vector the specified radians around the X axis and store the result into `dest`.
Parameters:
`angle` - the angle in radians
`dest` - will hold the result
Returns:
dest
• rotateY

```Vector3f rotateY​(float angle,
Vector3f dest)```
Rotate this vector the specified radians around the Y axis and store the result into `dest`.
Parameters:
`angle` - the angle in radians
`dest` - will hold the result
Returns:
dest
• rotateZ

```Vector3f rotateZ​(float angle,
Vector3f dest)```
Rotate this vector the specified radians around the Z axis and store the result into `dest`.
Parameters:
`angle` - the angle in radians
`dest` - will hold the result
Returns:
dest
• lengthSquared

`float lengthSquared()`
Return the length squared of this vector.
Returns:
the length squared
• length

`float length()`
Return the length of this vector.
Returns:
the length
• normalize

`Vector3f normalize​(Vector3f dest)`
Normalize this vector and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• normalize

```Vector3f normalize​(float length,
Vector3f dest)```
Scale this vector to have the given length and store the result in `dest`.
Parameters:
`length` - the desired length
`dest` - will hold the result
Returns:
dest
• cross

```Vector3f cross​(Vector3fc v,
Vector3f dest)```
Compute the cross product of this vector and `v` and store the result in `dest`.
Parameters:
`v` - the other vector
`dest` - will hold the result
Returns:
dest
• cross

```Vector3f 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`.
Parameters:
`x` - the x component of the other vector
`y` - the y component of the other vector
`z` - the z component of the other vector
`dest` - will hold the result
Returns:
dest
• distance

`float distance​(Vector3fc v)`
Return the distance between this Vector and `v`.
Parameters:
`v` - the other vector
Returns:
the distance
• distance

```float distance​(float x,
float y,
float z)```
Return the distance between `this` vector and `(x, y, z)`.
Parameters:
`x` - the x component of the other vector
`y` - the y component of the other vector
`z` - the z component of the other vector
Returns:
the euclidean distance
• distanceSquared

`float distanceSquared​(Vector3fc v)`
Return the square of the distance between this vector and `v`.
Parameters:
`v` - the other vector
Returns:
the squared of the distance
• distanceSquared

```float distanceSquared​(float x,
float y,
float z)```
Return the square of the distance between `this` vector and `(x, y, z)`.
Parameters:
`x` - the x component of the other vector
`y` - the y component of the other vector
`z` - the z component of the other vector
Returns:
the square of the distance
• dot

`float dot​(Vector3fc v)`
Return the dot product of this vector and the supplied vector.
Parameters:
`v` - the other vector
Returns:
the dot product
• dot

```float dot​(float x,
float y,
float z)```
Return the dot product of this vector and the vector `(x, y, z)`.
Parameters:
`x` - the x component of the other vector
`y` - the y component of the other vector
`z` - the z component of the other vector
Returns:
the dot product
• angleCos

`float angleCos​(Vector3fc v)`
Return the cosine of the angle between this vector and the supplied vector. Use this instead of Math.cos(this.angle(v)).
Parameters:
`v` - the other vector
Returns:
the cosine of the angle
`angle(Vector3fc)`
• angle

`float angle​(Vector3fc v)`
Return the angle between this vector and the supplied vector.
Parameters:
`v` - the other vector
Returns:
`angleCos(Vector3fc)`
• angleSigned

```float angleSigned​(Vector3fc v,
Vector3fc n)```
Return the signed angle between this vector and the supplied vector with respect to the plane with the given normal vector `n`.
Parameters:
`v` - the other vector
`n` - the plane's normal vector
Returns:
`angleCos(Vector3fc)`
• angleSigned

```float angleSigned​(float x,
float y,
float z,
float nx,
float ny,
float nz)```
Return the signed angle between this vector and the supplied vector with respect to the plane with the given normal vector `(nx, ny, nz)`.
Parameters:
`x` - the x coordinate of the other vector
`y` - the y coordinate of the other vector
`z` - the z coordinate of the other vector
`nx` - the x coordinate of the plane's normal vector
`ny` - the y coordinate of the plane's normal vector
`nz` - the z coordinate of the plane's normal vector
Returns:
• min

```Vector3f min​(Vector3fc v,
Vector3f dest)```
Set the components of `dest` to be the component-wise minimum of this and the other vector.
Parameters:
`v` - the other vector
`dest` - will hold the result
Returns:
dest
• max

```Vector3f max​(Vector3fc v,
Vector3f dest)```
Set the components of `dest` to be the component-wise maximum of this and the other vector.
Parameters:
`v` - the other vector
`dest` - will hold the result
Returns:
dest
• negate

`Vector3f negate​(Vector3f dest)`
Negate this vector and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• absolute

`Vector3f absolute​(Vector3f dest)`
Compute the absolute values of the individual components of `this` and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• reflect

```Vector3f reflect​(Vector3fc normal,
Vector3f dest)```
Reflect this vector about the given `normal` vector and store the result in `dest`.
Parameters:
`normal` - the vector to reflect about
`dest` - will hold the result
Returns:
dest
• reflect

```Vector3f reflect​(float x,
float y,
float z,
Vector3f dest)```
Reflect this vector about the given normal vector and store the result in `dest`.
Parameters:
`x` - the x component of the normal
`y` - the y component of the normal
`z` - the z component of the normal
`dest` - will hold the result
Returns:
dest
• half

```Vector3f half​(Vector3fc other,
Vector3f dest)```
Compute the half vector between this and the other vector and store the result in `dest`.
Parameters:
`other` - the other vector
`dest` - will hold the result
Returns:
dest
• half

```Vector3f 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`.
Parameters:
`x` - the x component of the other vector
`y` - the y component of the other vector
`z` - the z component of the other vector
`dest` - will hold the result
Returns:
dest
• smoothStep

```Vector3f smoothStep​(Vector3fc v,
float t,
Vector3f dest)```
Compute a smooth-step (i.e. hermite with zero tangents) interpolation between `this` vector and the given vector `v` and store the result in `dest`.
Parameters:
`v` - the other vector
`t` - the interpolation factor, within `[0..1]`
`dest` - will hold the result
Returns:
dest
• hermite

```Vector3f 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`.
Parameters:
`t0` - the tangent of `this` vector
`v1` - the other vector
`t1` - the tangent of the other vector
`t` - the interpolation factor, within `[0..1]`
`dest` - will hold the result
Returns:
dest
• lerp

```Vector3f lerp​(Vector3fc other,
float t,
Vector3f dest)```
Linearly interpolate `this` and `other` using the given interpolation factor `t` and store the result in `dest`.

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

Parameters:
`other` - the other vector
`t` - the interpolation factor between 0.0 and 1.0
`dest` - will hold the result
Returns:
dest
• get

```float get​(int component)
throws java.lang.IllegalArgumentException```
Get the value of the specified component of this vector.
Parameters:
`component` - the component, within `[0..2]`
Returns:
the value
Throws:
`java.lang.IllegalArgumentException` - if `component` is not within `[0..2]`
• get

```Vector3i get​(int mode,
Vector3i dest)```
Set the components of the given vector `dest` to those of `this` vector using the given `RoundingMode`.
Parameters:
`mode` - the `RoundingMode` to use
`dest` - will hold the result
Returns:
dest
• get

`Vector3f get​(Vector3f dest)`
Set the components of the given vector `dest` to those of `this` vector.
Parameters:
`dest` - will hold the result
Returns:
dest
• get

`Vector3d get​(Vector3d dest)`
Set the components of the given vector `dest` to those of `this` vector.
Parameters:
`dest` - will hold the result
Returns:
dest
• maxComponent

`int maxComponent()`
Determine the component with the biggest absolute value.
Returns:
the component index, within `[0..2]`
• minComponent

`int minComponent()`
Determine the component with the smallest (towards zero) absolute value.
Returns:
the component index, within `[0..2]`
• orthogonalize

```Vector3f 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`.

Reference: Gramâ€“Schmidt process

Parameters:
`v` - the reference vector which the result should be orthogonal to
`dest` - will hold the result
Returns:
dest
• orthogonalizeUnit

```Vector3f 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`.

The vector `v` is assumed to be a `unit` vector.

Reference: Gramâ€“Schmidt process

Parameters:
`v` - the reference unit vector which the result should be orthogonal to
`dest` - will hold the result
Returns:
dest
• floor

`Vector3f 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`.
Parameters:
`dest` - will hold the result
Returns:
dest
• ceil

`Vector3f 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`.
Parameters:
`dest` - will hold the result
Returns:
dest
• round

`Vector3f 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`.
Parameters:
`dest` - will hold the result
Returns:
dest
• isFinite

`boolean isFinite()`
Determine whether all components are finite floating-point values, that is, they are not `NaN` and not `infinity`.
Returns:
`true` if all components are finite floating-point values; `false` otherwise
• equals

```boolean equals​(Vector3fc v,
float delta)```
Compare the vector components of `this` vector with the given vector using the given `delta` and return whether all of them are equal within a maximum difference of `delta`.

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

Parameters:
`v` - the other vector
`delta` - the allowed maximum difference
Returns:
`true` whether all of the vector components are equal; `false` otherwise
• equals

```boolean equals​(float x,
float y,
float z)```
Compare the vector components of `this` vector with the given `(x, y, z)` and return whether all of them are equal.
Parameters:
`x` - the x component to compare to
`y` - the y component to compare to
`z` - the z component to compare to
Returns:
`true` if all the vector components are equal