Uses of Interface
org.joml.Vector2fc

Packages that use Vector2fc

Package	Description
org.joml	Contains all classes of JOML.

Uses of Vector2fc in org.joml

Classes in org.joml that implement Vector2fc

Modifier and Type	Class	Description
class	Vector2f	Represents a 2D vector with single-precision.

Methods in org.joml that return Vector2fc

Modifier and Type	Method	Description
Vector2fc	Vector2f.getToAddress(long address)
Vector2fc	Vector2fc.getToAddress(long address)	Store this vector at the given off-heap memory address.

Methods in org.joml with parameters of type Vector2fc

Modifier and Type	Method	Description
Vector2d	Vector2d.add(Vector2fc v)	Add v to this vector.
Vector2d	Vector2d.add(Vector2fc v, Vector2d dest)
Vector2d	Vector2dc.add(Vector2fc v, Vector2d dest)	Add v to this vector and store the result in dest.
Vector2f	Vector2f.add(Vector2fc v)	Add v to this vector.
Vector2f	Vector2f.add(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.add(Vector2fc v, Vector2f dest)	Add the supplied vector to this one and store the result in dest.
float	Vector2f.angle(Vector2fc v)
float	Vector2fc.angle(Vector2fc v)	Return the angle between this vector and the supplied vector.
static void	GeometryUtils.bitangent(Vector3fc v1, Vector2fc uv1, Vector3fc v2, Vector2fc uv2, Vector3fc v3, Vector2fc uv3, Vector3f dest)	Calculate the surface bitangent for the three supplied vertices and UV coordinates and store the result in dest.
double	Vector2d.distance(Vector2fc v)
double	Vector2dc.distance(Vector2fc v)	Return the distance between this and v.
float	Vector2f.distance(Vector2fc v)
float	Vector2fc.distance(Vector2fc v)	Return the distance between this and v.
double	Vector2d.distanceSquared(Vector2fc v)
double	Vector2dc.distanceSquared(Vector2fc v)	Return the distance squared between this and v.
float	Vector2f.distanceSquared(Vector2fc v)
float	Vector2fc.distanceSquared(Vector2fc v)	Return the distance squared between this and v.
Vector2d	Vector2d.div(Vector2fc v)	Divide this Vector3d component-wise by another Vector2fc.
Vector2d	Vector2d.div(Vector2fc v, Vector2d dest)
Vector2d	Vector2dc.div(Vector2fc v, Vector2d dest)	Divide this Vector2d component-wise by another Vector2f and store the result in dest.
Vector2f	Vector2f.div(Vector2fc v)	Divide this Vector2f component-wise by another Vector2fc.
Vector2f	Vector2f.div(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.div(Vector2fc v, Vector2f dest)	Divide this Vector2f component-wise by another Vector2fc and store the result in dest.
float	Vector2f.dot(Vector2fc v)
float	Vector2fc.dot(Vector2fc v)	Return the dot product of this vector and v.
boolean	Vector2f.equals(Vector2fc v, float delta)
boolean	Vector2fc.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.
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.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.
static boolean	Intersectionf.intersectCircleCircle(Vector2fc centerA, float radiusSquaredA, Vector2fc centerB, float radiusSquaredB, Vector3f intersectionCenterAndHL)	Test whether the one circle with center centerA and square radius radiusSquaredA intersects the other circle with center centerB and square radius radiusSquaredB, and store the center of the line segment of intersection in the (x, y) components of the supplied vector and the half-length of that line segment in the z component.
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(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 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(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 float	Intersectionf.intersectRayLine(Vector2fc origin, Vector2fc dir, Vector2fc point, Vector2fc normal, float epsilon)	Test whether the ray with given origin and direction dir intersects the line containing the given point and having the given normal, and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point.
static float	Intersectionf.intersectRayLineSegment(Vector2fc origin, Vector2fc dir, Vector2fc a, Vector2fc b)	Determine whether the ray with given origin and direction dir intersects the undirected line segment given by the two end points a and b, and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if any.
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(Vector2fc v)	Multiply this Vector2f component-wise by another Vector2f.
Vector2f	Vector2f.mul(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.mul(Vector2fc v, Vector2f dest)	Multiply this Vector2f component-wise by another Vector2f and store the result in dest.
Matrix3x2f	Matrix3x2f.rotateTo(Vector2fc fromDir, Vector2fc toDir)	Apply a rotation transformation to this matrix that rotates the given normalized fromDir direction vector to point along the normalized toDir.
Matrix3x2f	Matrix3x2f.rotateTo(Vector2fc fromDir, Vector2fc toDir, Matrix3x2f dest)	Apply a rotation transformation to this matrix that rotates the given normalized fromDir direction vector to point along the normalized toDir, and store the result in dest.
Matrix3x2f	Matrix3x2fc.rotateTo(Vector2fc fromDir, Vector2fc toDir, Matrix3x2f dest)	Apply a rotation transformation to this matrix that rotates the given normalized fromDir direction vector to point along the normalized toDir, and store the result in dest.
Matrix2f	Matrix2f.scale(Vector2fc xy)	Apply scaling to this matrix by scaling the base axes by the given xy.x and xy.y factors, respectively.
Matrix2f	Matrix2f.scale(Vector2fc xy, Matrix2f dest)
Matrix2f	Matrix2fc.scale(Vector2fc xy, Matrix2f dest)	Apply scaling to this matrix by scaling the base axes by the given xy.x and xy.y factors, respectively and store the result in dest.
Matrix3x2d	Matrix3x2d.scale(Vector2fc xy)	Apply scaling to this matrix by scaling the base axes by the given xy factors.
Matrix3x2d	Matrix3x2d.scale(Vector2fc xy, Matrix3x2d dest)	Apply scaling to this matrix by scaling the base axes by the given xy factors and store the result in dest.
Matrix3x2d	Matrix3x2dc.scale(Vector2fc xy, Matrix3x2d dest)	Apply scaling to this matrix by scaling the base axes by the given xy factors and store the result in dest.
Matrix3x2f	Matrix3x2f.scale(Vector2fc xy)	Apply scaling to this matrix by scaling the base axes by the given xy factors.
Matrix3x2f	Matrix3x2f.scale(Vector2fc xy, Matrix3x2f dest)	Apply scaling to this matrix by scaling the base axes by the given xy factors and store the result in dest.
Matrix3x2f	Matrix3x2fc.scale(Vector2fc xy, Matrix3x2f dest)	Apply scaling to this matrix by scaling the base axes by the given xy factors and store the result in dest.
Matrix2f	Matrix2f.scaling(Vector2fc xy)	Set this matrix to be a simple scale matrix which scales the base axes by xy.x and xy.y respectively.
Matrix2f	Matrix2f.set(Vector2fc col0, Vector2fc col1)	Set the two columns of this matrix to the supplied vectors, respectively.
Vector2d	Vector2d.set(Vector2fc v)	Set this Vector2d to be a clone of v.
Vector2f	Vector2f.set(Vector2fc v)	Set this Vector2f to the values of v.
Vector2i	Vector2i.set(Vector2fc v, int mode)	Set this Vector2i to the values of v using the given RoundingMode.
Vector3d	Vector3d.set(Vector2fc v, double z)	Set the first two components from the given v and the z component from the given z
Vector3f	Vector3f.set(Vector2fc v, float z)	Set the first two components from the given v and the z component from the given z
Vector4d	Vector4d.set(Vector2fc v, double z, double w)	Set the x and y components from the given v and the z and w components to the given z and w.
Vector4f	Vector4f.set(Vector2fc v, float z, float w)	Sets the first two components of this to the components of given v and last two components to the given z, and w.
Matrix2f	Matrix2f.setColumn(int column, Vector2fc src)	Set the column at the given column index, starting with 0.
Matrix2f	Matrix2f.setRow(int row, Vector2fc src)	Set the row at the given row index, starting with 0.
Vector2d	Vector2d.sub(Vector2fc v)	Subtract v from this vector.
Vector2d	Vector2d.sub(Vector2fc v, Vector2d dest)
Vector2d	Vector2dc.sub(Vector2fc v, Vector2d dest)	Subtract v from this vector and store the result in dest.
Vector2f	Vector2f.sub(Vector2fc v)	Subtract v from this vector.
Vector2f	Vector2f.sub(Vector2fc v, Vector2f dest)
Vector2f	Vector2fc.sub(Vector2fc v, Vector2f dest)	Subtract v from this vector and store the result in dest.
static void	GeometryUtils.tangent(Vector3fc v1, Vector2fc uv1, Vector3fc v2, Vector2fc uv2, Vector3fc v3, Vector2fc uv3, Vector3f dest)	Calculate the surface tangent for the three supplied vertices and UV coordinates and store the result in dest.
static void	GeometryUtils.tangentBitangent(Vector3fc v1, Vector2fc uv1, Vector3fc v2, Vector2fc uv2, Vector3fc v3, Vector2fc uv3, Vector3f destTangent, Vector3f destBitangent)	Calculate the surface tangent and bitangent for the three supplied vertices and UV coordinates and store the result in dest.
static boolean	Intersectionf.testAarAar(Vector2fc minA, Vector2fc maxA, Vector2fc minB, Vector2fc maxB)	Test whether the axis-aligned rectangle with minimum corner minA and maximum corner maxA intersects the axis-aligned rectangle with minimum corner minB and maximum corner maxB.
static boolean	Intersectionf.testAarCircle(Vector2fc min, Vector2fc max, Vector2fc center, float radiusSquared)	Test whether the axis-aligned rectangle with minimum corner min and maximum corner max intersects the circle with the given center and square radius radiusSquared.
static boolean	Intersectionf.testAarLine(Vector2fc min, Vector2fc max, float a, float b, float c)	Test whether the axis-aligned rectangle with minimum corner min and maximum corner max intersects the line with the general equation a*x + b*y + c = 0.
static boolean	Intersectionf.testCircleCircle(Vector2fc centerA, float radiusSquaredA, Vector2fc centerB, float radiusSquaredB)	Test whether the one circle with center centerA and square radius radiusSquaredA intersects the other circle with center centerB and square radius radiusSquaredB.
static boolean	Intersectionf.testCircleTriangle(Vector2fc center, float radiusSquared, Vector2fc v0, Vector2fc v1, Vector2fc v2)	Test whether the circle with given center and square radius radiusSquared intersects the triangle with counter-clockwise vertices v0, v1, v2.
boolean	FrustumIntersection.testPlaneXY(Vector2fc min, Vector2fc max)	Test whether the given XY-plane (at Z = 0) is partly or completely within or outside of the frustum defined by this frustum culler.
static boolean	Intersectionf.testPointTriangle(Vector2fc point, Vector2fc v0, Vector2fc v1, Vector2fc v2)	Test whether the given point lies inside the triangle with the vertices v0, v1, v2.
static boolean	Intersectionf.testRayAar(Vector2fc origin, Vector2fc dir, Vector2fc min, Vector2fc max)	Test whether the ray with the given origin and direction dir intersects the given axis-aligned rectangle specified as its minimum corner min and maximum corner max.
static boolean	Intersectionf.testRayCircle(Vector2fc origin, Vector2fc dir, Vector2fc center, float radiusSquared)	Test whether the ray with the given origin and direction dir intersects the circle with the given center and square radius.
Vector2f	Matrix2f.transform(Vector2fc v, Vector2f dest)
Vector2f	Matrix2fc.transform(Vector2fc v, Vector2f dest)	Transform the given vector by this matrix and store the result in dest.
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(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(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(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(Vector2fc v, Vector2f dest)
Vector2f	Matrix2fc.transformTranspose(Vector2fc v, Vector2f dest)	Transform the given vector by the transpose of this matrix and store the result in dest.
Matrix3x2f	Matrix3x2f.translate(Vector2fc offset)	Apply a translation to this matrix by translating by the given number of units in x and y.
Matrix3x2f	Matrix3x2f.translate(Vector2fc offset, Matrix3x2f dest)	Apply a translation to this matrix by translating by the given number of units in x and y, and store the result in dest.
Matrix3x2f	Matrix3x2fc.translate(Vector2fc offset, Matrix3x2f dest)	Apply a translation to this matrix by translating by the given number of units in x and y, and store the result in dest.
Matrix3x2f	Matrix3x2f.translateLocal(Vector2fc offset)	Pre-multiply a translation to this matrix by translating by the given number of units in x and y.
Matrix3x2f	Matrix3x2f.translateLocal(Vector2fc offset, Matrix3x2f dest)	Pre-multiply a translation to this matrix by translating by the given number of units in x and y and store the result in dest.
Matrix3x2f	Matrix3x2fc.translateLocal(Vector2fc offset, Matrix3x2f dest)	Pre-multiply a translation to this matrix by translating by the given number of units in x and y and store the result in dest.
Matrix3x2f	Matrix3x2f.translation(Vector2fc offset)	Set this matrix to be a simple translation matrix in a two-dimensional coordinate system.
Matrix4f	Matrix4f.unprojectInvRay(Vector2fc winCoords, int[] viewport, Vector3f originDest, Vector3f dirDest)
Matrix4f	Matrix4fc.unprojectInvRay(Vector2fc winCoords, int[] viewport, Vector3f originDest, Vector3f dirDest)	Unproject the given window coordinates winCoords by this matrix using the specified viewport and compute the origin and the direction of the resulting ray which starts at NDC z = -1.0 and goes through NDC z = +1.0.
Matrix4f	Matrix4f.unprojectRay(Vector2fc winCoords, int[] viewport, Vector3f originDest, Vector3f dirDest)
Matrix4f	Matrix4fc.unprojectRay(Vector2fc winCoords, int[] viewport, Vector3f originDest, Vector3f dirDest)	Unproject the given 2D window coordinates winCoords by this matrix using the specified viewport and compute the origin and the direction of the resulting ray which starts at NDC z = -1.0 and goes through NDC z = +1.0.

Constructors in org.joml with parameters of type Vector2fc

Modifier	Constructor	Description
	Matrix2f(Vector2fc col0, Vector2fc col1)	Create a new Matrix2f and initialize its two columns using the supplied vectors.
	Vector2d(Vector2fc v)	Create a new Vector2d and initialize its components to the one of the given vector.
	Vector2f(Vector2fc v)	Create a new Vector2f and initialize its components to the one of the given vector.
	Vector2i(Vector2fc v, int mode)	Create a new Vector2i and initialize its components to the rounded value of the given vector.
	Vector3d(Vector2fc v, double z)	Create a new Vector3d with the first two components from the given v and the given z
	Vector3f(Vector2fc v, float z)	Create a new Vector3f with the first two components from the given v and the given z
	Vector3i(Vector2fc v, float z, int mode)	Create a new Vector3i with the first two components from the given v and the given z and round using the given RoundingMode.
	Vector4d(Vector2fc v, double z, double w)	Create a new Vector4d with the x and y components from the given v and the z and w components from the given z and w.
	Vector4f(Vector2fc v, float z, float w)	Create a new Vector4f with the first two components from the given v and the given z, and w.