org.joml

Interface Vector2fc

All Known Implementing Classes:

Vector2f

public interface Vector2fc

Interface to an immutable 2-dimensional vector of single-precision floats.

Author:

Kai Burjack

Method Summary

Modifier and Type	Method and 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.
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.
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.
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.
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.
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	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	negate(Vector2f dest) Negate this vector and store the result in dest.
Vector2f	normalize(Vector2f dest) Normalize this vector 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

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 order

Returns:

the passed in buffer

See Also:

get(int, ByteBuffer)

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 order

Returns:

the passed in buffer

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 order

Returns:

the passed in buffer

See Also:

get(int, FloatBuffer)

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 order

Returns:

the passed in buffer

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:

the angle, in radians

length

float length()

Return the length of this vector.

Returns:

the length

lengthSquared

float lengthSquared()

Return the length squared of this vector.

Returns:

the length squared

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

add

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

add

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

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