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.
|