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

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.
`ByteBuffer`
```get(int index, ByteBuffer buffer)```
Store this vector into the supplied `ByteBuffer` starting at the specified absolute buffer position/index.
`FloatBuffer`
```get(int index, 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`.
`ByteBuffer`
`get(ByteBuffer buffer)`
Store this vector into the supplied `ByteBuffer` at the current buffer `position`.
`FloatBuffer`
`get(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. hermite with zero tangents) interpolation between `this` vector and the given vector `v` and store the result in `dest`.
`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 Details

• ### 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

FloatBuffer get(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

FloatBuffer get(int index, 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

ByteBuffer get(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

ByteBuffer get(int index, 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

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

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
• ### 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
• ### 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
• ### 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

float angle(Vector3fc v)
Return the angle between this vector and the supplied vector.
Parameters:
`v` - the other vector
Returns:
• ### 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:
• ### 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 IllegalArgumentException
Get the value of the specified component of this vector.
Parameters:
`component` - the component, within `[0..2]`
Returns:
the value
Throws:
`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