Package org.joml

## Interface Vector2fc

• All Known Implementing Classes:
`Vector2f`

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

All Methods
Modifier and Type Method Description
`Vector2f` ```add​(float x, float y, Vector2f dest)```
Increment the components of this vector by the given values and store the result in `dest`.
`Vector2f` ```add​(Vector2fc v, Vector2f dest)```
Add the supplied vector to this one and store the result in `dest`.
`float` `angle​(Vector2fc v)`
Return the angle between this vector and the supplied vector.
`Vector2f` `ceil​(Vector2f 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`.
`float` ```distance​(float x, float y)```
Return the distance between `this` vector and `(x, y)`.
`float` `distance​(Vector2fc v)`
Return the distance between this and `v`.
`float` ```distanceSquared​(float x, float y)```
Return the distance squared between `this` vector and `(x, y)`.
`float` `distanceSquared​(Vector2fc v)`
Return the distance squared between this and `v`.
`float` `dot​(Vector2fc v)`
Return the dot product of this vector and `v`.
`boolean` ```equals​(float x, float y)```
Compare the vector components of `this` vector with the given `(x, y)` and return whether all of them are equal.
`boolean` ```equals​(Vector2fc 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`.
`Vector2f` `floor​(Vector2f 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`.
`Vector2f` ```fma​(float a, Vector2fc b, Vector2f dest)```
Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector2f` ```fma​(Vector2fc a, Vector2fc b, Vector2f 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.
`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`.
`Vector2fc` `getToAddress​(long address)`
Store this vector at the given off-heap memory address.
`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.
`Vector2f` ```lerp​(Vector2fc other, float t, Vector2f dest)```
Linearly interpolate `this` and `other` using the given interpolation factor `t` and store the result in `dest`.
`Vector2f` ```max​(Vector2fc v, Vector2f 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.
`Vector2f` ```min​(Vector2fc v, Vector2f 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.
`Vector2f` ```mul​(float x, float y, Vector2f dest)```
Multiply the components of this Vector2f by the given scalar values and store the result in `dest`.
`Vector2f` ```mul​(float scalar, Vector2f dest)```
Multiply the components of this vector by the given scalar and store the result in `dest`.
`Vector2f` ```mul​(Vector2fc v, Vector2f dest)```
Multiply this Vector2f component-wise by another Vector2f and store the result in `dest`.
`Vector2f` ```mulDirection​(Matrix3x2fc mat, Vector2f dest)```
Multiply the given 3x2 matrix `mat` with `this` and store the result in `dest`.
`Vector2f` ```mulPosition​(Matrix3x2fc mat, Vector2f dest)```
Multiply the given 3x2 matrix `mat` with `this` and store the result in `dest`.
`Vector2f` `negate​(Vector2f dest)`
Negate this vector and store the result in `dest`.
`Vector2f` ```normalize​(float length, Vector2f dest)```
Scale this vector to have the given length and store the result in `dest`.
`Vector2f` `normalize​(Vector2f dest)`
Normalize this vector and store the result in `dest`.
`Vector2f` `round​(Vector2f 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`.
`Vector2f` ```sub​(float x, float y, Vector2f dest)```
Subtract `(x, y)` from this vector and store the result in `dest`.
`Vector2f` ```sub​(Vector2fc v, Vector2f dest)```
Subtract `v` from `this` vector and store the result in `dest`.
`float` `x()`
`float` `y()`
• ### Method Detail

• #### x

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

`float y()`
Returns:
the value of the y component
• #### 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` order
Returns:
the passed in buffer
`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` order
Returns:
the passed in buffer
• #### 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` order
Returns:
the passed in buffer
`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` order
Returns:
the passed in buffer

`Vector2fc 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

```Vector2f sub​(Vector2fc v,
Vector2f dest)```
Subtract `v` from `this` vector and store the result in `dest`.
Parameters:
`v` - the vector to subtract
`dest` - will hold the result
Returns:
dest
• #### sub

```Vector2f sub​(float x,
float y,
Vector2f dest)```
Subtract `(x, y)` from this vector and store the result in `dest`.
Parameters:
`x` - the x component to subtract
`y` - the y component to subtract
`dest` - will hold the result
Returns:
dest
• #### dot

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

`float angle​(Vector2fc v)`
Return the angle between this vector and the supplied vector.
Parameters:
`v` - the other vector
Returns:
• #### 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
• #### distance

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

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

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

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

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

```Vector2f normalize​(float length,
Vector2f 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

```Vector2f add​(Vector2fc v,
Vector2f 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

```Vector2f add​(float x,
float y,
Vector2f 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
`dest` - will hold the result
Returns:
dest
• #### negate

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

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

```Vector2f mul​(float x,
float y,
Vector2f dest)```
Multiply the components of this Vector2f 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
`dest` - will hold the result
Returns:
dest
• #### mul

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

```Vector2f mulPosition​(Matrix3x2fc mat,
Vector2f dest)```
Multiply the given 3x2 matrix `mat` with `this` and store the result in `dest`.

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

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

```Vector2f mulDirection​(Matrix3x2fc mat,
Vector2f dest)```
Multiply the given 3x2 matrix `mat` with `this` and store the result in `dest`.

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

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

```Vector2f lerp​(Vector2fc other,
float t,
Vector2f 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
• #### fma

```Vector2f fma​(Vector2fc a,
Vector2fc b,
Vector2f 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

```Vector2f fma​(float a,
Vector2fc b,
Vector2f 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
• #### min

```Vector2f min​(Vector2fc v,
Vector2f 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

```Vector2f max​(Vector2fc v,
Vector2f 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
• #### maxComponent

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

`int minComponent()`
Determine the component with the smallest (towards zero) absolute value.
Returns:
the component index, within `[0..1]`
• #### 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..1]`
Returns:
the value
Throws:
`java.lang.IllegalArgumentException` - if `component` is not within `[0..1]`
• #### floor

`Vector2f floor​(Vector2f 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

`Vector2f ceil​(Vector2f 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

`Vector2f round​(Vector2f 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​(Vector2fc 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)```
Compare the vector components of `this` vector with the given `(x, y)` and return whether all of them are equal.
Parameters:
`x` - the x component to compare to
`y` - the y component to compare to
Returns:
`true` if all the vector components are equal