Interface Vector2fc

 All Known Implementing Classes:
Vector2f
public interface Vector2fc
Interface to a readonly view of a 2dimensional vector of singleprecision floats. Author:
 Kai Burjack


Method Summary
All Methods Instance Methods Abstract 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 indest
.Vector2f
add(Vector2fc v, Vector2f dest)
Add the supplied vector to this one and store the result indest
.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 indest
.float
distance(float x, float y)
Return the distance betweenthis
vector and(x, y)
.float
distance(Vector2fc v)
Return the distance between this andv
.float
distanceSquared(float x, float y)
Return the distance squared betweenthis
vector and(x, y)
.float
distanceSquared(Vector2fc v)
Return the distance squared between this andv
.float
dot(Vector2fc v)
Return the dot product of this vector andv
.boolean
equals(float x, float y)
Compare the vector components ofthis
vector with the given(x, y)
and return whether all of them are equal.boolean
equals(Vector2fc v, float delta)
Compare the vector components ofthis
vector with the given vector using the givendelta
and return whether all of them are equal within a maximum difference ofdelta
.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 indest
.Vector2f
fma(float a, Vector2fc b, Vector2f dest)
Add the componentwise multiplication ofa * b
to this vector and store the result indest
.Vector2f
fma(Vector2fc a, Vector2fc b, Vector2f dest)
Add the componentwise multiplication ofa * b
to this vector and store the result indest
.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 suppliedByteBuffer
starting at the specified absolute buffer position/index.java.nio.FloatBuffer
get(int index, java.nio.FloatBuffer buffer)
Store this vector into the suppliedFloatBuffer
starting at the specified absolute buffer position/index.java.nio.ByteBuffer
get(java.nio.ByteBuffer buffer)
Store this vector into the suppliedByteBuffer
at the current bufferposition
.java.nio.FloatBuffer
get(java.nio.FloatBuffer buffer)
Store this vector into the suppliedFloatBuffer
at the current bufferposition
.Vector2fc
getToAddress(long address)
Store this vector at the given offheap memory address.boolean
isFinite()
Determine whether all components are finite floatingpoint values, that is, they are notNaN
and notinfinity
.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 interpolatethis
andother
using the given interpolation factort
and store the result indest
.Vector2f
max(Vector2fc v, Vector2f dest)
Set the components ofdest
to be the componentwise 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 ofdest
to be the componentwise 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 indest
.Vector2f
mul(float scalar, Vector2f dest)
Multiply the components of this vector by the given scalar and store the result indest
.Vector2f
mul(Vector2fc v, Vector2f dest)
Multiply this Vector2f componentwise by another Vector2f and store the result indest
.Vector2f
mulDirection(Matrix3x2fc mat, Vector2f dest)
Multiply the given 3x2 matrixmat
withthis
and store the result indest
.Vector2f
mulPosition(Matrix3x2fc mat, Vector2f dest)
Multiply the given 3x2 matrixmat
withthis
and store the result indest
.Vector2f
negate(Vector2f dest)
Negate this vector and store the result indest
.Vector2f
normalize(float length, Vector2f dest)
Scale this vector to have the given length and store the result indest
.Vector2f
normalize(Vector2f dest)
Normalize this vector and store the result indest
.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 indest
.Vector2f
sub(float x, float y, Vector2f dest)
Subtract(x, y)
from this vector and store the result indest
.Vector2f
sub(Vector2fc v, Vector2f dest)
Subtractv
fromthis
vector and store the result indest
.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 suppliedByteBuffer
at the current bufferposition
.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 inx, y
order Returns:
 the passed in buffer
 See Also:
get(int, ByteBuffer)

get
java.nio.ByteBuffer get(int index, java.nio.ByteBuffer buffer)
Store this vector into the suppliedByteBuffer
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 ByteBufferbuffer
 will receive the values of this vector inx, y
order Returns:
 the passed in buffer

get
java.nio.FloatBuffer get(java.nio.FloatBuffer buffer)
Store this vector into the suppliedFloatBuffer
at the current bufferposition
.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 inx, y
order Returns:
 the passed in buffer
 See Also:
get(int, FloatBuffer)

get
java.nio.FloatBuffer get(int index, java.nio.FloatBuffer buffer)
Store this vector into the suppliedFloatBuffer
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 FloatBufferbuffer
 will receive the values of this vector inx, y
order Returns:
 the passed in buffer

getToAddress
Vector2fc getToAddress(long address)
Store this vector at the given offheap 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 offheap address where to store this vector Returns:
 this

sub
Vector2f sub(Vector2fc v, Vector2f dest)
Subtractv
fromthis
vector and store the result indest
. Parameters:
v
 the vector to subtractdest
 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 indest
. Parameters:
x
 the x component to subtracty
 the y component to subtractdest
 will hold the result Returns:
 dest

dot
float dot(Vector2fc v)
Return the dot product of this vector andv
. 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:
 the angle, in radians

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 andv
. Parameters:
v
 the other vector Returns:
 the distance

distanceSquared
float distanceSquared(Vector2fc v)
Return the distance squared between this andv
. Parameters:
v
 the other vector Returns:
 the distance squared

distance
float distance(float x, float y)
Return the distance betweenthis
vector and(x, y)
. Parameters:
x
 the x component of the other vectory
 the y component of the other vector Returns:
 the euclidean distance

distanceSquared
float distanceSquared(float x, float y)
Return the distance squared betweenthis
vector and(x, y)
. Parameters:
x
 the x component of the other vectory
 the y component of the other vector Returns:
 the euclidean distance squared

normalize
Vector2f normalize(Vector2f dest)
Normalize this vector and store the result indest
. 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 indest
. Parameters:
length
 the desired lengthdest
 will hold the result Returns:
 dest

add
Vector2f add(Vector2fc v, Vector2f dest)
Add the supplied vector to this one and store the result indest
. Parameters:
v
 the vector to adddest
 will hold the result Returns:
 dest

add
Vector2f add(float x, float y, Vector2f dest)
Increment the components of this vector by the given values and store the result indest
. Parameters:
x
 the x component to addy
 the y component to adddest
 will hold the result Returns:
 dest

negate
Vector2f negate(Vector2f dest)
Negate this vector and store the result indest
. 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 indest
. Parameters:
scalar
 the value to multiply this vector's components bydest
 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 indest
. Parameters:
x
 the x component to multiply this vector byy
 the y component to multiply this vector bydest
 will hold the result Returns:
 dest

mul
Vector2f mul(Vector2fc v, Vector2f dest)
Multiply this Vector2f componentwise by another Vector2f and store the result indest
. Parameters:
v
 the vector to multiply bydest
 will hold the result Returns:
 dest

mulPosition
Vector2f mulPosition(Matrix3x2fc mat, Vector2f dest)
Multiply the given 3x2 matrixmat
withthis
and store the result indest
.This method assumes the
z
component ofthis
to be1.0
. Parameters:
mat
 the matrix to multiply this vector bydest
 will hold the result Returns:
 dest

mulDirection
Vector2f mulDirection(Matrix3x2fc mat, Vector2f dest)
Multiply the given 3x2 matrixmat
withthis
and store the result indest
.This method assumes the
z
component ofthis
to be0.0
. Parameters:
mat
 the matrix to multiply this vector bydest
 will hold the result Returns:
 dest

lerp
Vector2f lerp(Vector2fc other, float t, Vector2f dest)
Linearly interpolatethis
andother
using the given interpolation factort
and store the result indest
.If
t
is0.0
then the result isthis
. If the interpolation factor is1.0
then the result isother
. Parameters:
other
 the other vectort
 the interpolation factor between 0.0 and 1.0dest
 will hold the result Returns:
 dest

fma
Vector2f fma(Vector2fc a, Vector2fc b, Vector2f dest)
Add the componentwise multiplication ofa * b
to this vector and store the result indest
. Parameters:
a
 the first multiplicandb
 the second multiplicanddest
 will hold the result Returns:
 dest

fma
Vector2f fma(float a, Vector2fc b, Vector2f dest)
Add the componentwise multiplication ofa * b
to this vector and store the result indest
. Parameters:
a
 the first multiplicandb
 the second multiplicanddest
 will hold the result Returns:
 dest

min
Vector2f min(Vector2fc v, Vector2f dest)
Set the components ofdest
to be the componentwise minimum of this and the other vector. Parameters:
v
 the other vectordest
 will hold the result Returns:
 dest

max
Vector2f max(Vector2fc v, Vector2f dest)
Set the components ofdest
to be the componentwise maximum of this and the other vector. Parameters:
v
 the other vectordest
 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
 ifcomponent
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 indest
. 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 indest
. 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 indest
. Parameters:
dest
 will hold the result Returns:
 dest

isFinite
boolean isFinite()
Determine whether all components are finite floatingpoint values, that is, they are notNaN
and notinfinity
. Returns:
true
if all components are finite floatingpoint values;false
otherwise

equals
boolean equals(Vector2fc v, float delta)
Compare the vector components ofthis
vector with the given vector using the givendelta
and return whether all of them are equal within a maximum difference ofdelta
.Please note that this method is not used by any data structure such as
ArrayList
HashSet
orHashMap
and their operations, such asArrayList.contains(Object)
orHashSet.remove(Object)
, since those data structures only use theObject.equals(Object)
andObject.hashCode()
methods. Parameters:
v
 the other vectordelta
 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 ofthis
vector with the given(x, y)
and return whether all of them are equal. Parameters:
x
 the x component to compare toy
 the y component to compare to Returns:
true
if all the vector components are equal

