Uses of Class
org.joml.Vector2f

Packages that use Vector2f

Package	Description
org.joml	Contains all classes of JOML.

Uses of Vector2f in org.joml

Methods in org.joml that return Vector2f

Modifier and Type	Method	Description
Vector2f	Vector2f.absolute()	Set this vector's components to their respective absolute values.
Vector2f	Vector2f.absolute(Vector2f dest)
Vector2f	Vector2fc.absolute(Vector2f dest)	Compute the absolute of each of this vector's components and store the result into dest.
Vector2f	Vector2f.add(float x, float y)	Increment the components of this vector by the given values.
Vector2f	Vector2f.add(float x, float y, Vector2f dest)
Vector2f	Vector2f.add(Vector2fc v)	Add v to this vector.
Vector2f	Vector2f.add(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.add(float x, float y, Vector2f dest)	Increment the components of this vector by the given values and store the result in dest.
Vector2f	Vector2fc.add(Vector2fc v, Vector2f dest)	Add the supplied vector to this one and store the result in dest.
Vector2f	Vector2f.ceil()	Ceil each component of this vector
Vector2f	Vector2f.ceil(Vector2f dest)
Vector2f	Vector2fc.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.
static Vector2f	Interpolationf.dFdxLinear(float v0X, float v0Y, float f0X, float f0Y, float v1X, float v1Y, float f1X, float f1Y, float v2X, float v2Y, float f2X, float f2Y, Vector2f dest)	Compute the first-order derivative of a linear two-dimensional function f with respect to X and store the result in dest.
static Vector2f	Interpolationf.dFdyLinear(float v0X, float v0Y, float f0X, float f0Y, float v1X, float v1Y, float f1X, float f1Y, float v2X, float v2Y, float f2X, float f2Y, Vector2f dest)	Compute the first-order derivative of a linear two-dimensional function f with respect to Y and store the result in dest.
Vector2f	Vector2f.div(float scalar)	Divide all components of this Vector2f by the given scalar value.
Vector2f	Vector2f.div(float x, float y)	Divide the components of this Vector2f by the given scalar values and store the result in this.
Vector2f	Vector2f.div(float x, float y, Vector2f dest)
Vector2f	Vector2f.div(float scalar, Vector2f dest)
Vector2f	Vector2f.div(Vector2fc v)	Divide this Vector2f component-wise by another Vector2fc.
Vector2f	Vector2f.div(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.div(float x, float y, Vector2f dest)	Divide the components of this Vector2f by the given scalar values and store the result in dest.
Vector2f	Vector2fc.div(float scalar, Vector2f dest)	Divide all components of this Vector2f by the given scalar value and store the result in dest.
Vector2f	Vector2fc.div(Vector2fc v, Vector2f dest)	Divide this Vector2f component-wise by another Vector2fc and store the result in dest.
Vector2f	Vector2f.floor()	Set each component of this vector to the largest (closest to positive infinity) float value that is less than or equal to that component and is equal to a mathematical integer.
Vector2f	Vector2f.floor(Vector2f dest)
Vector2f	Vector2fc.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	Vector2f.fma(float a, Vector2fc b)	Add the component-wise multiplication of a * b to this vector.
Vector2f	Vector2f.fma(float a, Vector2fc b, Vector2f dest)
Vector2f	Vector2f.fma(Vector2fc a, Vector2fc b)	Add the component-wise multiplication of a * b to this vector.
Vector2f	Vector2f.fma(Vector2fc a, Vector2fc b, Vector2f dest)
Vector2f	Vector2fc.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	Vector2fc.fma(Vector2fc a, Vector2fc b, Vector2f dest)	Add the component-wise multiplication of a * b to this vector and store the result in dest.
Vector2f	Vector2d.get(Vector2f dest)
Vector2f	Vector2dc.get(Vector2f dest)	Set the components of the given vector dest to those of this vector.
Vector2f	Vector2f.get(Vector2f dest)
Vector2f	Vector2fc.get(Vector2f dest)	Set the components of the given vector dest to those of this vector.
Vector2f	Matrix2f.getColumn(int column, Vector2f dest)
Vector2f	Matrix2fc.getColumn(int column, Vector2f dest)	Get the column at the given column index, starting with 0.
Vector2f	Matrix2f.getRow(int row, Vector2f dest)
Vector2f	Matrix2fc.getRow(int row, Vector2f dest)	Get the row at the given row index, starting with 0.
Vector2f	Matrix2f.getScale(Vector2f dest)
Vector2f	Matrix2fc.getScale(Vector2f dest)	Get the scaling factors of this matrix for the three base axes.
static Vector2f	Interpolationf.interpolateTriangle(float v0X, float v0Y, float f0X, float f0Y, float v1X, float v1Y, float f1X, float f1Y, float v2X, float v2Y, float f2X, float f2Y, float x, float y, Vector2f dest)	Bilinearly interpolate the two-dimensional vector f over the given triangle and store the result in dest.
Vector2f	Vector2f.lerp(Vector2fc other, float t)	Linearly interpolate this and other using the given interpolation factor t and store the result in this.
Vector2f	Vector2f.lerp(Vector2fc other, float t, Vector2f dest)
Vector2f	Vector2fc.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	Vector2f.max(Vector2fc v)	Set the components of this vector to be the component-wise maximum of this and the other vector.
Vector2f	Vector2f.max(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.max(Vector2fc v, Vector2f dest)	Set the components of dest to be the component-wise maximum of this and the other vector.
Vector2f	Vector2f.min(Vector2fc v)	Set the components of this vector to be the component-wise minimum of this and the other vector.
Vector2f	Vector2f.min(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.min(Vector2fc v, Vector2f dest)	Set the components of dest to be the component-wise minimum of this and the other vector.
Vector2f	Vector2f.mul(float scalar)	Multiply the components of this vector by the given scalar.
Vector2f	Vector2f.mul(float x, float y)	Multiply the components of this Vector2f by the given scalar values and store the result in this.
Vector2f	Vector2f.mul(float x, float y, Vector2f dest)
Vector2f	Vector2f.mul(float scalar, Vector2f dest)
Vector2f	Vector2f.mul(Matrix2dc mat)	Multiply the given matrix with this Vector2f and store the result in this.
Vector2f	Vector2f.mul(Matrix2dc mat, Vector2f dest)
Vector2f	Vector2f.mul(Matrix2fc mat)	Multiply the given matrix with this Vector2f and store the result in this.
Vector2f	Vector2f.mul(Matrix2fc mat, Vector2f dest)
Vector2f	Vector2f.mul(Vector2fc v)	Multiply this Vector2f component-wise by another Vector2f.
Vector2f	Vector2f.mul(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.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	Vector2fc.mul(float scalar, Vector2f dest)	Multiply the components of this vector by the given scalar and store the result in dest.
Vector2f	Vector2fc.mul(Matrix2dc mat, Vector2f dest)	Multiply the given matrix with this Vector2f and store the result in dest.
Vector2f	Vector2fc.mul(Matrix2fc mat, Vector2f dest)	Multiply the given matrix with this Vector2f and store the result in dest.
Vector2f	Vector2fc.mul(Vector2fc v, Vector2f dest)	Multiply this Vector2f component-wise by another Vector2f and store the result in dest.
Vector2f	Vector2f.mulDirection(Matrix3x2fc mat)	Multiply the given 3x2 matrix mat with this.
Vector2f	Vector2f.mulDirection(Matrix3x2fc mat, Vector2f dest)
Vector2f	Vector2fc.mulDirection(Matrix3x2fc mat, Vector2f dest)	Multiply the given 3x2 matrix mat with this and store the result in dest.
Vector2f	Vector2f.mulPosition(Matrix3x2fc mat)	Multiply the given 3x2 matrix mat with this.
Vector2f	Vector2f.mulPosition(Matrix3x2fc mat, Vector2f dest)
Vector2f	Vector2fc.mulPosition(Matrix3x2fc mat, Vector2f dest)	Multiply the given 3x2 matrix mat with this and store the result in dest.
Vector2f	Vector2f.mulTranspose(Matrix2fc mat)	Multiply the transpose of the given matrix with this Vector2f store the result in this.
Vector2f	Vector2f.mulTranspose(Matrix2fc mat, Vector2f dest)
Vector2f	Vector2fc.mulTranspose(Matrix2fc mat, Vector2f dest)	Multiply the transpose of the given matrix with this Vector3f and store the result in dest.
Vector2f	Vector2f.negate()	Negate this vector.
Vector2f	Vector2f.negate(Vector2f dest)
Vector2f	Vector2fc.negate(Vector2f dest)	Negate this vector and store the result in dest.
Vector2f	Vector2f.normalize()	Normalize this vector.
Vector2f	Vector2f.normalize(float length)	Scale this vector to have the given length.
Vector2f	Vector2f.normalize(float length, Vector2f dest)
Vector2f	Vector2f.normalize(Vector2f dest)
Vector2f	Vector2fc.normalize(float length, Vector2f dest)	Scale this vector to have the given length and store the result in dest.
Vector2f	Vector2fc.normalize(Vector2f dest)	Normalize this vector and store the result in dest.
Vector2f	Matrix2f.normalizedPositiveX(Vector2f dir)
Vector2f	Matrix2fc.normalizedPositiveX(Vector2f dest)	Obtain the direction of +X before the transformation represented by this orthogonal matrix is applied.
Vector2f	Matrix3x2f.normalizedPositiveX(Vector2f dir)
Vector2f	Matrix3x2fc.normalizedPositiveX(Vector2f dir)	Obtain the direction of +X before the transformation represented by this orthogonal matrix is applied.
Vector2f	Matrix2f.normalizedPositiveY(Vector2f dir)
Vector2f	Matrix2fc.normalizedPositiveY(Vector2f dest)	Obtain the direction of +Y before the transformation represented by this orthogonal matrix is applied.
Vector2f	Matrix3x2f.normalizedPositiveY(Vector2f dir)
Vector2f	Matrix3x2fc.normalizedPositiveY(Vector2f dir)	Obtain the direction of +Y before the transformation represented by this orthogonal matrix is applied.
Vector2f	Matrix3x2f.origin(Vector2f origin)	Obtain the position that gets transformed to the origin by this matrix.
Vector2f	Matrix3x2fc.origin(Vector2f origin)	Obtain the position that gets transformed to the origin by this matrix.
Vector2f	Vector2f.perpendicular()	Set this vector to be one of its perpendicular vectors.
Vector2f	Matrix2f.positiveX(Vector2f dir)
Vector2f	Matrix2fc.positiveX(Vector2f dest)	Obtain the direction of +X before the transformation represented by this matrix is applied.
Vector2f	Matrix3x2f.positiveX(Vector2f dir)
Vector2f	Matrix3x2fc.positiveX(Vector2f dir)	Obtain the direction of +X before the transformation represented by this matrix is applied.
Vector2f	Matrix2f.positiveY(Vector2f dir)
Vector2f	Matrix2fc.positiveY(Vector2f dest)	Obtain the direction of +Y before the transformation represented by this matrix is applied.
Vector2f	Matrix3x2f.positiveY(Vector2f dir)
Vector2f	Matrix3x2fc.positiveY(Vector2f dir)	Obtain the direction of +Y before the transformation represented by this matrix is applied.
Vector2f	Vector2f.round()	Set each component of this vector to the closest float that is equal to a mathematical integer, with ties rounding to positive infinity.
Vector2f	Vector2f.round(Vector2f dest)
Vector2f	Vector2fc.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	Vector2f.set(double d)	Set the x and y components to the supplied value.
Vector2f	Vector2f.set(double x, double y)	Set the x and y components to the supplied values.
Vector2f	Vector2f.set(float d)	Set the x and y components to the supplied value.
Vector2f	Vector2f.set(float[] xy)	Set the two components of this vector to the first two elements of the given array.
Vector2f	Vector2f.set(float x, float y)	Set the x and y components to the supplied values.
Vector2f	Vector2f.set(int index, ByteBuffer buffer)	Read this vector from the supplied ByteBuffer starting at the specified absolute buffer position/index.
Vector2f	Vector2f.set(int index, FloatBuffer buffer)	Read this vector from the supplied FloatBuffer starting at the specified absolute buffer position/index.
Vector2f	Vector2f.set(ByteBuffer buffer)	Read this vector from the supplied ByteBuffer at the current buffer position.
Vector2f	Vector2f.set(FloatBuffer buffer)	Read this vector from the supplied FloatBuffer at the current buffer position.
Vector2f	Vector2f.set(Vector2dc v)	Set this Vector2f to the values of v.
Vector2f	Vector2f.set(Vector2fc v)	Set this Vector2f to the values of v.
Vector2f	Vector2f.set(Vector2ic v)	Set this Vector2f to the values of v.
Vector2f	Vector2f.setComponent(int component, float value)	Set the value of the specified component of this vector.
Vector2f	Vector2f.setFromAddress(long address)	Set the values of this vector by reading 2 float values from off-heap memory, starting at the given address.
Vector2f	Vector2f.sub(float x, float y)	Subtract (x, y) from this vector.
Vector2f	Vector2f.sub(float x, float y, Vector2f dest)
Vector2f	Vector2f.sub(Vector2fc v)	Subtract v from this vector.
Vector2f	Vector2f.sub(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.sub(float x, float y, Vector2f dest)	Subtract (x, y) from this vector and store the result in dest.
Vector2f	Vector2fc.sub(Vector2fc v, Vector2f dest)	Subtract v from this vector and store the result in dest.
Vector2f	Matrix2f.transform(float x, float y, Vector2f dest)
Vector2f	Matrix2f.transform(Vector2f v)
Vector2f	Matrix2f.transform(Vector2fc v, Vector2f dest)
Vector2f	Matrix2fc.transform(float x, float y, Vector2f dest)	Transform the vector (x, y) by this matrix and store the result in dest.
Vector2f	Matrix2fc.transform(Vector2f v)	Transform the given vector by this matrix.
Vector2f	Matrix2fc.transform(Vector2fc v, Vector2f dest)	Transform the given vector by this matrix and store the result in dest.
Vector2f	Matrix3x2f.transformDirection(float x, float y, Vector2f dest)	Transform/multiply the given 2D-vector (x, y), as if it was a 3D-vector with z=0, by this matrix and store the result in dest.
Vector2f	Matrix3x2f.transformDirection(Vector2f v)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=0, by this matrix and store the result in that vector.
Vector2f	Matrix3x2f.transformDirection(Vector2fc v, Vector2f dest)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=0, by this matrix and store the result in dest.
Vector2f	Matrix3x2fc.transformDirection(float x, float y, Vector2f dest)	Transform/multiply the given 2D-vector (x, y), as if it was a 3D-vector with z=0, by this matrix and store the result in dest.
Vector2f	Matrix3x2fc.transformDirection(Vector2f v)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=0, by this matrix and store the result in that vector.
Vector2f	Matrix3x2fc.transformDirection(Vector2fc v, Vector2f dest)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=0, by this matrix and store the result in dest.
Vector2f	Matrix3x2f.transformPosition(float x, float y, Vector2f dest)	Transform/multiply the given 2D-vector (x, y), as if it was a 3D-vector with z=1, by this matrix and store the result in dest.
Vector2f	Matrix3x2f.transformPosition(Vector2f v)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=1, by this matrix and store the result in that vector.
Vector2f	Matrix3x2f.transformPosition(Vector2fc v, Vector2f dest)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=1, by this matrix and store the result in dest.
Vector2f	Matrix3x2fc.transformPosition(float x, float y, Vector2f dest)	Transform/multiply the given 2D-vector (x, y), as if it was a 3D-vector with z=1, by this matrix and store the result in dest.
Vector2f	Matrix3x2fc.transformPosition(Vector2f v)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=1, by this matrix and store the result in that vector.
Vector2f	Matrix3x2fc.transformPosition(Vector2fc v, Vector2f dest)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=1, by this matrix and store the result in dest.
Vector2f	Matrix2f.transformTranspose(float x, float y, Vector2f dest)
Vector2f	Matrix2f.transformTranspose(Vector2f v)
Vector2f	Matrix2f.transformTranspose(Vector2fc v, Vector2f dest)
Vector2f	Matrix2fc.transformTranspose(float x, float y, Vector2f dest)	Transform the vector (x, y) by the transpose of this matrix and store the result in dest.
Vector2f	Matrix2fc.transformTranspose(Vector2f v)	Transform the given vector by the transpose of this matrix.
Vector2f	Matrix2fc.transformTranspose(Vector2fc v, Vector2f dest)	Transform the given vector by the transpose of this matrix and store the result in dest.
Vector2f	Matrix3x2f.unproject(float winX, float winY, int[] viewport, Vector2f dest)	Unproject the given window coordinates (winX, winY) by this matrix using the specified viewport.
Vector2f	Matrix3x2fc.unproject(float winX, float winY, int[] viewport, Vector2f dest)	Unproject the given window coordinates (winX, winY) by this matrix using the specified viewport.
Vector2f	Matrix3x2f.unprojectInv(float winX, float winY, int[] viewport, Vector2f dest)	Unproject the given window coordinates (winX, winY) by this matrix using the specified viewport.
Vector2f	Matrix3x2fc.unprojectInv(float winX, float winY, int[] viewport, Vector2f dest)	Unproject the given window coordinates (winX, winY) by this matrix using the specified viewport.
Vector2f	Vector2f.zero()	Set all components to zero.

Methods in org.joml with parameters of type Vector2f

Modifier and Type	Method	Description
Vector2f	Vector2f.absolute(Vector2f dest)
Vector2f	Vector2fc.absolute(Vector2f dest)	Compute the absolute of each of this vector's components and store the result into dest.
Vector2f	Vector2f.add(float x, float y, Vector2f dest)
Vector2f	Vector2f.add(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.add(float x, float y, Vector2f dest)	Increment the components of this vector by the given values and store the result in dest.
Vector2f	Vector2fc.add(Vector2fc v, Vector2f dest)	Add the supplied vector to this one and store the result in dest.
Vector2f	Vector2f.ceil(Vector2f dest)
Vector2f	Vector2fc.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.
static Vector2f	Interpolationf.dFdxLinear(float v0X, float v0Y, float f0X, float f0Y, float v1X, float v1Y, float f1X, float f1Y, float v2X, float v2Y, float f2X, float f2Y, Vector2f dest)	Compute the first-order derivative of a linear two-dimensional function f with respect to X and store the result in dest.
static Vector2f	Interpolationf.dFdyLinear(float v0X, float v0Y, float f0X, float f0Y, float v1X, float v1Y, float f1X, float f1Y, float v2X, float v2Y, float f2X, float f2Y, Vector2f dest)	Compute the first-order derivative of a linear two-dimensional function f with respect to Y and store the result in dest.
Vector2f	Vector2f.div(float x, float y, Vector2f dest)
Vector2f	Vector2f.div(float scalar, Vector2f dest)
Vector2f	Vector2f.div(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.div(float x, float y, Vector2f dest)	Divide the components of this Vector2f by the given scalar values and store the result in dest.
Vector2f	Vector2fc.div(float scalar, Vector2f dest)	Divide all components of this Vector2f by the given scalar value and store the result in dest.
Vector2f	Vector2fc.div(Vector2fc v, Vector2f dest)	Divide this Vector2f component-wise by another Vector2fc and store the result in dest.
static int	Intersectionf.findClosestPointOnTriangle(float v0X, float v0Y, float v1X, float v1Y, float v2X, float v2Y, float pX, float pY, Vector2f result)	Determine the closest point on the triangle with the given vertices (v0X, v0Y), (v1X, v1Y), (v2X, v2Y) between that triangle and the given point (pX, pY) and store that point into the given result.
static int	Intersectionf.findClosestPointOnTriangle(Vector2fc v0, Vector2fc v1, Vector2fc v2, Vector2fc p, Vector2f result)	Determine the closest point on the triangle with the vertices v0, v1, v2 between that triangle and the given point p and store that point into the given result.
Vector2f	Vector2f.floor(Vector2f dest)
Vector2f	Vector2fc.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	Vector2f.fma(float a, Vector2fc b, Vector2f dest)
Vector2f	Vector2f.fma(Vector2fc a, Vector2fc b, Vector2f dest)
Vector2f	Vector2fc.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	Vector2fc.fma(Vector2fc a, Vector2fc b, Vector2f dest)	Add the component-wise multiplication of a * b to this vector and store the result in dest.
Vector2f	Vector2d.get(Vector2f dest)
Vector2f	Vector2dc.get(Vector2f dest)	Set the components of the given vector dest to those of this vector.
Vector2f	Vector2f.get(Vector2f dest)
Vector2f	Vector2fc.get(Vector2f dest)	Set the components of the given vector dest to those of this vector.
Vector2f	Matrix2f.getColumn(int column, Vector2f dest)
Vector2f	Matrix2fc.getColumn(int column, Vector2f dest)	Get the column at the given column index, starting with 0.
Vector2f	Matrix2f.getRow(int row, Vector2f dest)
Vector2f	Matrix2fc.getRow(int row, Vector2f dest)	Get the row at the given row index, starting with 0.
Vector2f	Matrix2f.getScale(Vector2f dest)
Vector2f	Matrix2fc.getScale(Vector2f dest)	Get the scaling factors of this matrix for the three base axes.
static Vector2f	Interpolationf.interpolateTriangle(float v0X, float v0Y, float f0X, float f0Y, float v1X, float v1Y, float f1X, float f1Y, float v2X, float v2Y, float f2X, float f2Y, float x, float y, Vector2f dest)	Bilinearly interpolate the two-dimensional vector f over the given triangle and store the result in dest.
static boolean	Intersectionf.intersectLineLine(float ps1x, float ps1y, float pe1x, float pe1y, float ps2x, float ps2y, float pe2x, float pe2y, Vector2f p)	Determine whether the two lines, specified via two points lying on each line, intersect each other, and store the point of intersection into the given vector p.
static int	Intersectionf.intersectLineSegmentAab(float p0X, float p0Y, float p0Z, float p1X, float p1Y, float p1Z, float minX, float minY, float minZ, float maxX, float maxY, float maxZ, Vector2f result)	Determine whether the undirected line segment with the end points (p0X, p0Y, p0Z) and (p1X, p1Y, p1Z) intersects the axis-aligned box given as its minimum corner (minX, minY, minZ) and maximum corner (maxX, maxY, maxZ), and return the values of the parameter t in the ray equation p(t) = origin + p0 * (p1 - p0) of the near and far point of intersection.
static int	Intersectionf.intersectLineSegmentAab(Vector3fc p0, Vector3fc p1, Vector3fc min, Vector3fc max, Vector2f result)	Determine whether the undirected line segment with the end points p0 and p1 intersects the axis-aligned box given as its minimum corner min and maximum corner max, and return the values of the parameter t in the ray equation p(t) = origin + p0 * (p1 - p0) of the near and far point of intersection.
static int	Intersectionf.intersectLineSegmentAar(float p0X, float p0Y, float p1X, float p1Y, float minX, float minY, float maxX, float maxY, Vector2f result)	Determine whether the undirected line segment with the end points (p0X, p0Y) and (p1X, p1Y) intersects the axis-aligned rectangle given as its minimum corner (minX, minY) and maximum corner (maxX, maxY), and store the values of the parameter t in the ray equation p(t) = p0 + t * (p1 - p0) of the near and far point of intersection into result.
static int	Intersectionf.intersectLineSegmentAar(Vector2fc p0, Vector2fc p1, Vector2fc min, Vector2fc max, Vector2f result)	Determine whether the undirected line segment with the end points p0 and p1 intersects the axis-aligned rectangle given as its minimum corner min and maximum corner max, and store the values of the parameter t in the ray equation p(t) = p0 + t * (p1 - p0) of the near and far point of intersection into result.
static int	Intersectionf.intersectPolygonRay(float[] verticesXY, float originX, float originY, float dirX, float dirY, Vector2f p)	Determine whether the polygon specified by the given sequence of (x, y) coordinate pairs intersects with the ray with given origin (originX, originY, originZ) and direction (dirX, dirY, dirZ), and store the point of intersection into the given vector p.
static int	Intersectionf.intersectPolygonRay(Vector2fc[] vertices, float originX, float originY, float dirX, float dirY, Vector2f p)	Determine whether the polygon specified by the given sequence of vertices intersects with the ray with given origin (originX, originY, originZ) and direction (dirX, dirY, dirZ), and store the point of intersection into the given vector p.
static boolean	Intersectionf.intersectRayAab(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float minX, float minY, float minZ, float maxX, float maxY, float maxZ, Vector2f result)	Test whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the axis-aligned box given as its minimum corner (minX, minY, minZ) and maximum corner (maxX, maxY, maxZ), and return the values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection.
static boolean	Intersectionf.intersectRayAab(Vector3fc origin, Vector3fc dir, Vector3fc min, Vector3fc max, Vector2f result)	Test whether the ray with the given origin and direction dir intersects the axis-aligned box specified as its minimum corner min and maximum corner max, and return the values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection..
static int	Intersectionf.intersectRayAar(float originX, float originY, float dirX, float dirY, float minX, float minY, float maxX, float maxY, Vector2f result)	Determine whether the given ray with the origin (originX, originY) and direction (dirX, dirY) intersects the axis-aligned rectangle given as its minimum corner (minX, minY) and maximum corner (maxX, maxY), and return the values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection as well as the side of the axis-aligned rectangle the ray intersects.
static int	Intersectionf.intersectRayAar(Vector2fc origin, Vector2fc dir, Vector2fc min, Vector2fc max, Vector2f result)	Determine whether the given ray with the given origin and direction dir intersects the axis-aligned rectangle given as its minimum corner min and maximum corner max, and return the values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection as well as the side of the axis-aligned rectangle the ray intersects.
static boolean	Intersectionf.intersectRayCircle(float originX, float originY, float dirX, float dirY, float centerX, float centerY, float radiusSquared, Vector2f result)	Test whether the given ray with the origin (originX, originY) and direction (dirX, dirY) intersects the given circle with center (centerX, centerY) and square radius radiusSquared, and store the values of the parameter t in the ray equation p(t) = origin + t * dir for both points (near and far) of intersections into the given result vector.
static boolean	Intersectionf.intersectRayCircle(Vector2fc origin, Vector2fc dir, Vector2fc center, float radiusSquared, Vector2f result)	Test whether the ray with the given origin and direction dir intersects the circle with the given center and square radius radiusSquared, and store the values of the parameter t in the ray equation p(t) = origin + t * dir for both points (near and far) of intersections into the given result vector.
static boolean	Intersectionf.intersectRaySphere(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float centerX, float centerY, float centerZ, float radiusSquared, Vector2f result)	Test whether the given ray with the origin (originX, originY, originZ) and normalized direction (dirX, dirY, dirZ) intersects the given sphere with center (centerX, centerY, centerZ) and square radius radiusSquared, and store the values of the parameter t in the ray equation p(t) = origin + t * dir for both points (near and far) of intersections into the given result vector.
static boolean	Intersectionf.intersectRaySphere(Vector3fc origin, Vector3fc dir, Vector3fc center, float radiusSquared, Vector2f result)	Test whether the ray with the given origin and normalized direction dir intersects the sphere with the given center and square radius radiusSquared, and store the values of the parameter t in the ray equation p(t) = origin + t * dir for both points (near and far) of intersections into the given result vector.
Vector2f	Vector2f.lerp(Vector2fc other, float t, Vector2f dest)
Vector2f	Vector2fc.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	Vector2f.max(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.max(Vector2fc v, Vector2f dest)	Set the components of dest to be the component-wise maximum of this and the other vector.
Vector2f	Vector2f.min(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.min(Vector2fc v, Vector2f dest)	Set the components of dest to be the component-wise minimum of this and the other vector.
Vector2f	Vector2f.mul(float x, float y, Vector2f dest)
Vector2f	Vector2f.mul(float scalar, Vector2f dest)
Vector2f	Vector2f.mul(Matrix2dc mat, Vector2f dest)
Vector2f	Vector2f.mul(Matrix2fc mat, Vector2f dest)
Vector2f	Vector2f.mul(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.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	Vector2fc.mul(float scalar, Vector2f dest)	Multiply the components of this vector by the given scalar and store the result in dest.
Vector2f	Vector2fc.mul(Matrix2dc mat, Vector2f dest)	Multiply the given matrix with this Vector2f and store the result in dest.
Vector2f	Vector2fc.mul(Matrix2fc mat, Vector2f dest)	Multiply the given matrix with this Vector2f and store the result in dest.
Vector2f	Vector2fc.mul(Vector2fc v, Vector2f dest)	Multiply this Vector2f component-wise by another Vector2f and store the result in dest.
Vector2f	Vector2f.mulDirection(Matrix3x2fc mat, Vector2f dest)
Vector2f	Vector2fc.mulDirection(Matrix3x2fc mat, Vector2f dest)	Multiply the given 3x2 matrix mat with this and store the result in dest.
Vector2f	Vector2f.mulPosition(Matrix3x2fc mat, Vector2f dest)
Vector2f	Vector2fc.mulPosition(Matrix3x2fc mat, Vector2f dest)	Multiply the given 3x2 matrix mat with this and store the result in dest.
Vector2f	Vector2f.mulTranspose(Matrix2fc mat, Vector2f dest)
Vector2f	Vector2fc.mulTranspose(Matrix2fc mat, Vector2f dest)	Multiply the transpose of the given matrix with this Vector3f and store the result in dest.
Vector2f	Vector2f.negate(Vector2f dest)
Vector2f	Vector2fc.negate(Vector2f dest)	Negate this vector and store the result in dest.
Vector2f	Vector2f.normalize(float length, Vector2f dest)
Vector2f	Vector2f.normalize(Vector2f dest)
Vector2f	Vector2fc.normalize(float length, Vector2f dest)	Scale this vector to have the given length and store the result in dest.
Vector2f	Vector2fc.normalize(Vector2f dest)	Normalize this vector and store the result in dest.
Vector2f	Matrix2f.normalizedPositiveX(Vector2f dir)
Vector2f	Matrix2fc.normalizedPositiveX(Vector2f dest)	Obtain the direction of +X before the transformation represented by this orthogonal matrix is applied.
Vector2f	Matrix3x2f.normalizedPositiveX(Vector2f dir)
Vector2f	Matrix3x2fc.normalizedPositiveX(Vector2f dir)	Obtain the direction of +X before the transformation represented by this orthogonal matrix is applied.
Vector2f	Matrix2f.normalizedPositiveY(Vector2f dir)
Vector2f	Matrix2fc.normalizedPositiveY(Vector2f dest)	Obtain the direction of +Y before the transformation represented by this orthogonal matrix is applied.
Vector2f	Matrix3x2f.normalizedPositiveY(Vector2f dir)
Vector2f	Matrix3x2fc.normalizedPositiveY(Vector2f dir)	Obtain the direction of +Y before the transformation represented by this orthogonal matrix is applied.
Vector2f	Matrix3x2f.origin(Vector2f origin)	Obtain the position that gets transformed to the origin by this matrix.
Vector2f	Matrix3x2fc.origin(Vector2f origin)	Obtain the position that gets transformed to the origin by this matrix.
Vector2f	Matrix2f.positiveX(Vector2f dir)
Vector2f	Matrix2fc.positiveX(Vector2f dest)	Obtain the direction of +X before the transformation represented by this matrix is applied.
Vector2f	Matrix3x2f.positiveX(Vector2f dir)
Vector2f	Matrix3x2fc.positiveX(Vector2f dir)	Obtain the direction of +X before the transformation represented by this matrix is applied.
Vector2f	Matrix2f.positiveY(Vector2f dir)
Vector2f	Matrix2fc.positiveY(Vector2f dest)	Obtain the direction of +Y before the transformation represented by this matrix is applied.
Vector2f	Matrix3x2f.positiveY(Vector2f dir)
Vector2f	Matrix3x2fc.positiveY(Vector2f dir)	Obtain the direction of +Y before the transformation represented by this matrix is applied.
Vector2f	Vector2f.round(Vector2f dest)
Vector2f	Vector2fc.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.
Matrix3x2f	Matrix3x2f.setTranslation(Vector2f offset)	Set only the translation components of this matrix (m20, m21) to the given values (offset.x, offset.y).
Matrix3x2f	Matrix3x2f.span(Vector2f corner, Vector2f xDir, Vector2f yDir)	Compute the extents of the coordinate system before this transformation was applied and store the resulting corner coordinates in corner and the span vectors in xDir and yDir.
Vector2f	Vector2f.sub(float x, float y, Vector2f dest)
Vector2f	Vector2f.sub(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.sub(float x, float y, Vector2f dest)	Subtract (x, y) from this vector and store the result in dest.
Vector2f	Vector2fc.sub(Vector2fc v, Vector2f dest)	Subtract v from this vector and store the result in dest.
static boolean	Intersectionf.testMovingCircleCircle(Vector2f centerA, Vector2f moveA, float aR, Vector2f centerB, float bR)	Test whether a given circle with center centerA and radius aR and travelled distance vector moveA intersects a given static circle with center centerB and radius bR.
static boolean	Intersectionf.testPolygonPolygon(Vector2f[] v1s, Vector2f[] v2s)	Test if the two convex polygons, given via their vertices, intersect.
Vector2f	Matrix2f.transform(float x, float y, Vector2f dest)
Vector2f	Matrix2f.transform(Vector2f v)
Vector2f	Matrix2f.transform(Vector2fc v, Vector2f dest)
Vector2f	Matrix2fc.transform(float x, float y, Vector2f dest)	Transform the vector (x, y) by this matrix and store the result in dest.
Vector2f	Matrix2fc.transform(Vector2f v)	Transform the given vector by this matrix.
Vector2f	Matrix2fc.transform(Vector2fc v, Vector2f dest)	Transform the given vector by this matrix and store the result in dest.
Vector2f	Matrix3x2f.transformDirection(float x, float y, Vector2f dest)	Transform/multiply the given 2D-vector (x, y), as if it was a 3D-vector with z=0, by this matrix and store the result in dest.
Vector2f	Matrix3x2f.transformDirection(Vector2f v)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=0, by this matrix and store the result in that vector.
Vector2f	Matrix3x2f.transformDirection(Vector2fc v, Vector2f dest)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=0, by this matrix and store the result in dest.
Vector2f	Matrix3x2fc.transformDirection(float x, float y, Vector2f dest)	Transform/multiply the given 2D-vector (x, y), as if it was a 3D-vector with z=0, by this matrix and store the result in dest.
Vector2f	Matrix3x2fc.transformDirection(Vector2f v)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=0, by this matrix and store the result in that vector.
Vector2f	Matrix3x2fc.transformDirection(Vector2fc v, Vector2f dest)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=0, by this matrix and store the result in dest.
Vector2f	Matrix3x2f.transformPosition(float x, float y, Vector2f dest)	Transform/multiply the given 2D-vector (x, y), as if it was a 3D-vector with z=1, by this matrix and store the result in dest.
Vector2f	Matrix3x2f.transformPosition(Vector2f v)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=1, by this matrix and store the result in that vector.
Vector2f	Matrix3x2f.transformPosition(Vector2fc v, Vector2f dest)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=1, by this matrix and store the result in dest.
Vector2f	Matrix3x2fc.transformPosition(float x, float y, Vector2f dest)	Transform/multiply the given 2D-vector (x, y), as if it was a 3D-vector with z=1, by this matrix and store the result in dest.
Vector2f	Matrix3x2fc.transformPosition(Vector2f v)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=1, by this matrix and store the result in that vector.
Vector2f	Matrix3x2fc.transformPosition(Vector2fc v, Vector2f dest)	Transform/multiply the given 2D-vector, as if it was a 3D-vector with z=1, by this matrix and store the result in dest.
Vector2f	Matrix2f.transformTranspose(float x, float y, Vector2f dest)
Vector2f	Matrix2f.transformTranspose(Vector2f v)
Vector2f	Matrix2f.transformTranspose(Vector2fc v, Vector2f dest)
Vector2f	Matrix2fc.transformTranspose(float x, float y, Vector2f dest)	Transform the vector (x, y) by the transpose of this matrix and store the result in dest.
Vector2f	Matrix2fc.transformTranspose(Vector2f v)	Transform the given vector by the transpose of this matrix.
Vector2f	Matrix2fc.transformTranspose(Vector2fc v, Vector2f dest)	Transform the given vector by the transpose of this matrix and store the result in dest.
Vector2f	Matrix3x2f.unproject(float winX, float winY, int[] viewport, Vector2f dest)	Unproject the given window coordinates (winX, winY) by this matrix using the specified viewport.
Vector2f	Matrix3x2fc.unproject(float winX, float winY, int[] viewport, Vector2f dest)	Unproject the given window coordinates (winX, winY) by this matrix using the specified viewport.
Vector2f	Matrix3x2f.unprojectInv(float winX, float winY, int[] viewport, Vector2f dest)	Unproject the given window coordinates (winX, winY) by this matrix using the specified viewport.
Vector2f	Matrix3x2fc.unprojectInv(float winX, float winY, int[] viewport, Vector2f dest)	Unproject the given window coordinates (winX, winY) by this matrix using the specified viewport.