org.joml.primitives

Class Intersectionf

java.lang.Object

org.joml.primitives.Intersectionf

public class Intersectionf
extends Object

Contains intersection and distance tests for some 2D and 3D geometric primitives.

Author:

Kai Burjack

Field Summary

Fields

Modifier and Type	Field and Description
static int	AAR_SIDE_MAXX Return value of intersectRayAar(float, float, float, float, float, float, float, float, Vector2f) and intersectRayAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the ray intersects the side of the axis-aligned rectangle with the maximum x coordinate.
static int	AAR_SIDE_MAXY Return value of intersectRayAar(float, float, float, float, float, float, float, float, Vector2f) and intersectRayAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the ray intersects the side of the axis-aligned rectangle with the maximum y coordinate.
static int	AAR_SIDE_MINX Return value of intersectRayAar(float, float, float, float, float, float, float, float, Vector2f) and intersectRayAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the ray intersects the side of the axis-aligned rectangle with the minimum x coordinate.
static int	AAR_SIDE_MINY Return value of intersectRayAar(float, float, float, float, float, float, float, float, Vector2f) and intersectRayAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the ray intersects the side of the axis-aligned rectangle with the minimum y coordinate.
static int	INSIDE Return value of intersectLineSegmentAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f) to indicate that the line segment lies completely inside of the axis-aligned box; or return value of intersectLineSegmentAar(float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the line segment lies completely inside of the axis-aligned rectangle.
static int	ONE_INTERSECTION Return value of intersectLineSegmentAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f) to indicate that one end point of the line segment lies inside of the axis-aligned box; or return value of intersectLineSegmentAar(float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that one end point of the line segment lies inside of the axis-aligned rectangle.
static int	OUTSIDE Return value of intersectLineSegmentAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f) to indicate that the line segment does not intersect the axis-aligned box; or return value of intersectLineSegmentAar(float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the line segment does not intersect the axis-aligned rectangle.
static int	POINT_ON_TRIANGLE_EDGE_01 Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point lies on the edge between the first and second vertex of the triangle.
static int	POINT_ON_TRIANGLE_EDGE_12 Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point lies on the edge between the second and third vertex of the triangle.
static int	POINT_ON_TRIANGLE_EDGE_20 Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point lies on the edge between the third and first vertex of the triangle.
static int	POINT_ON_TRIANGLE_FACE Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point lies on the face of the triangle.
static int	POINT_ON_TRIANGLE_VERTEX_0 Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point is the first vertex of the triangle.
static int	POINT_ON_TRIANGLE_VERTEX_1 Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point is the second vertex of the triangle.
static int	POINT_ON_TRIANGLE_VERTEX_2 Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point is the third vertex of the triangle.
static int	TWO_INTERSECTION Return value of intersectLineSegmentAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f) to indicate that the line segment intersects two sides of the axis-aligned box or lies on an edge or a side of the box; or return value of intersectLineSegmentAar(float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the line segment intersects two edges of the axis-aligned rectangle or lies on an edge of the rectangle.

Constructor Summary

Constructors

Constructor and Description
Intersectionf()

Method Summary

Modifier and Type	Method and Description
static float	distancePointLine(float pointX, float pointY, float a, float b, float c) Determine the signed distance of the given point (pointX, pointY) to the line specified via its general plane equation a*x + b*y + c = 0.
static float	distancePointLine(float pointX, float pointY, float x0, float y0, float x1, float y1) Determine the signed distance of the given point (pointX, pointY) to the line defined by the two points (x0, y0) and (x1, y1).
static float	distancePointLine(float pX, float pY, float pZ, float x0, float y0, float z0, float x1, float y1, float z1) Compute the distance of the given point (pX, pY, pZ) to the line defined by the two points (x0, y0, z0) and (x1, y1, z1).
static float	distancePointPlane(float pointX, float pointY, float pointZ, float a, float b, float c, float d) Determine the signed distance of the given point (pointX, pointY, pointZ) to the plane specified via its general plane equation a*x + b*y + c*z + d = 0.
static float	distancePointPlane(float pointX, float pointY, float pointZ, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z) Determine the signed distance of the given point (pointX, pointY, pointZ) to the plane of the triangle specified by its three points (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z).
static org.joml.Vector3f	findClosestPointOnLineSegment(float aX, float aY, float aZ, float bX, float bY, float bZ, float pX, float pY, float pZ, org.joml.Vector3f result) Find the point on the given line segment which is closest to the specified point (pX, pY, pZ), and store the result in result.
static org.joml.Vector3f	findClosestPointOnPlane(float aX, float aY, float aZ, float nX, float nY, float nZ, float pX, float pY, float pZ, org.joml.Vector3f result) Find the point on the given plane which is closest to the specified point (pX, pY, pZ) and store the result in result.
static org.joml.Vector3f	findClosestPointOnRectangle(float aX, float aY, float aZ, float bX, float bY, float bZ, float cX, float cY, float cZ, float pX, float pY, float pZ, org.joml.Vector3f res) Find the point on a given rectangle, specified via three of its corners, which is closest to the specified point (pX, pY, pZ) and store the result into res.
static int	findClosestPointOnTriangle(float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z, float pX, float pY, float pZ, org.joml.Vector3f result) Determine the closest point on the triangle with the given vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z), (v2X, v2Y, v2Z) between that triangle and the given point (pX, pY, pZ) and store that point into the given result.
static int	findClosestPointOnTriangle(float v0X, float v0Y, float v1X, float v1Y, float v2X, float v2Y, float pX, float pY, org.joml.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	findClosestPointOnTriangle(org.joml.Vector2fc v0, org.joml.Vector2fc v1, org.joml.Vector2fc v2, org.joml.Vector2fc p, org.joml.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.
static int	findClosestPointOnTriangle(org.joml.Vector3fc v0, org.joml.Vector3fc v1, org.joml.Vector3fc v2, org.joml.Vector3fc p, org.joml.Vector3f 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.
static float	findClosestPointsLineSegments(float a0X, float a0Y, float a0Z, float a1X, float a1Y, float a1Z, float b0X, float b0Y, float b0Z, float b1X, float b1Y, float b1Z, org.joml.Vector3f resultA, org.joml.Vector3f resultB) Find the closest points on the two line segments, store the point on the first line segment in resultA and the point on the second line segment in resultB, and return the square distance between both points.
static float	findClosestPointsLineSegmentTriangle(float aX, float aY, float aZ, float bX, float bY, float bZ, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z, org.joml.Vector3f lineSegmentResult, org.joml.Vector3f triangleResult) Find the closest points on a line segment and a triangle.
static boolean	intersectCircleCircle(float aX, float aY, float radiusSquaredA, float bX, float bY, float radiusSquaredB, org.joml.Vector3f intersectionCenterAndHL) Test whether the one circle with center (aX, aY) and square radius radiusSquaredA intersects the other circle with center (bX, bY) 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 boolean	intersectCircleCircle(org.joml.Vector2fc centerA, float radiusSquaredA, org.joml.Vector2fc centerB, float radiusSquaredB, org.joml.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 boolean	intersectLineCircle(float x0, float y0, float x1, float y1, float centerX, float centerY, float radius, org.joml.Vector3f intersectionCenterAndHL) Test whether the line defined by the two points (x0, y0) and (x1, y1) intersects the circle with center (centerX, centerY) and radius, 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 boolean	intersectLineCircle(float a, float b, float c, float centerX, float centerY, float radius, org.joml.Vector3f intersectionCenterAndHL) Test whether the line with the general line equation a*x + b*y + c = 0 intersects the circle with center (centerX, centerY) and radius, 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 boolean	intersectLineLine(float ps1x, float ps1y, float pe1x, float pe1y, float ps2x, float ps2y, float pe2x, float pe2y, org.joml.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	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, org.joml.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	intersectLineSegmentAab(LineSegmentf lineSegment, AABBf aabb, org.joml.Vector2f result) Determine whether the given undirected line segment intersects the given axis-aligned box, 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	intersectLineSegmentAab(LineSegmentf lineSegment, AABBi aabb, org.joml.Vector2f result) Determine whether the given undirected line segment intersects the given axis-aligned box, 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	intersectLineSegmentAab(org.joml.Vector3fc p0, org.joml.Vector3fc p1, org.joml.Vector3fc min, org.joml.Vector3fc max, org.joml.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	intersectLineSegmentAar(float p0X, float p0Y, float p1X, float p1Y, float minX, float minY, float maxX, float maxY, org.joml.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	intersectLineSegmentAar(org.joml.Vector2fc p0, org.joml.Vector2fc p1, org.joml.Vector2fc min, org.joml.Vector2fc max, org.joml.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 boolean	intersectLineSegmentPlane(float p0X, float p0Y, float p0Z, float p1X, float p1Y, float p1Z, float a, float b, float c, float d, org.joml.Vector3f intersectionPoint) Determine whether the line segment with the end points (p0X, p0Y, p0Z) and (p1X, p1Y, p1Z) intersects the plane given as the general plane equation a*x + b*y + c*z + d = 0, and return the point of intersection.
static boolean	intersectLineSegmentTriangle(float p0X, float p0Y, float p0Z, float p1X, float p1Y, float p1Z, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z, float epsilon, org.joml.Vector3f intersectionPoint) Determine whether the line segment with the end points (p0X, p0Y, p0Z) and (p1X, p1Y, p1Z) intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z), regardless of the winding order of the triangle or the direction of the line segment between its two end points, and return the point of intersection.
static boolean	intersectLineSegmentTriangle(org.joml.Vector3fc p0, org.joml.Vector3fc p1, org.joml.Vector3fc v0, org.joml.Vector3fc v1, org.joml.Vector3fc v2, float epsilon, org.joml.Vector3f intersectionPoint) Determine whether the line segment with the end points p0 and p1 intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z), regardless of the winding order of the triangle or the direction of the line segment between its two end points, and return the point of intersection.
static boolean	intersectPlaneSphere(float a, float b, float c, float d, float centerX, float centerY, float centerZ, float radius, org.joml.Vector4f intersectionCenterAndRadius) Test whether the plane with the general plane equation a*x + b*y + c*z + d = 0 intersects the sphere with center (centerX, centerY, centerZ) and radius, and store the center of the circle of intersection in the (x, y, z) components of the supplied vector and the radius of that circle in the w component.
static boolean	intersectPlaneSweptSphere(float a, float b, float c, float d, float cX, float cY, float cZ, float radius, float vX, float vY, float vZ, org.joml.Vector4f pointAndTime) Test whether the plane with the general plane equation a*x + b*y + c*z + d = 0 intersects the moving sphere with center (cX, cY, cZ), radius and velocity (vX, vY, vZ), and store the point of intersection in the (x, y, z) components of the supplied vector and the time of intersection in the w component.
static int	intersectPolygonRay(float[] verticesXY, float originX, float originY, float dirX, float dirY, org.joml.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	intersectPolygonRay(org.joml.Vector2fc[] vertices, float originX, float originY, float dirX, float dirY, org.joml.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	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, org.joml.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	intersectRayAab(Rayf ray, AABBf aabb, org.joml.Vector2f result) Test whether the given ray intersects given the axis-aligned box 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	intersectRayAab(Rayf ray, AABBi aabb, org.joml.Vector2f result) Test whether the given ray intersects given the axis-aligned box 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	intersectRayAab(org.joml.Vector3fc origin, org.joml.Vector3fc dir, org.joml.Vector3fc min, org.joml.Vector3fc max, org.joml.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	intersectRayAar(float originX, float originY, float dirX, float dirY, float minX, float minY, float maxX, float maxY, org.joml.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	intersectRayAar(org.joml.Vector2fc origin, org.joml.Vector2fc dir, org.joml.Vector2fc min, org.joml.Vector2fc max, org.joml.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	intersectRayCircle(float originX, float originY, float dirX, float dirY, float centerX, float centerY, float radiusSquared, org.joml.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	intersectRayCircle(org.joml.Vector2fc origin, org.joml.Vector2fc dir, org.joml.Vector2fc center, float radiusSquared, org.joml.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	intersectRayLine(float originX, float originY, float dirX, float dirY, float pointX, float pointY, float normalX, float normalY, float epsilon) Test whether the ray with given origin (originX, originY) and direction (dirX, dirY) intersects the line containing the given point (pointX, pointY) and having the normal (normalX, normalY), and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point.
static float	intersectRayLine(org.joml.Vector2fc origin, org.joml.Vector2fc dir, org.joml.Vector2fc point, org.joml.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	intersectRayLineSegment(float originX, float originY, float dirX, float dirY, float aX, float aY, float bX, float bY) Determine whether the ray with given origin (originX, originY) and direction (dirX, dirY) intersects the undirected line segment given by the two end points (aX, bY) and (bX, bY), and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if any.
static float	intersectRayLineSegment(org.joml.Vector2fc origin, org.joml.Vector2fc dir, org.joml.Vector2fc a, org.joml.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.
static float	intersectRayPlane(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float a, float b, float c, float d, float epsilon) Test whether the ray with given origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the plane given as the general plane equation a*x + b*y + c*z + d = 0, and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point.
static float	intersectRayPlane(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float pointX, float pointY, float pointZ, float normalX, float normalY, float normalZ, float epsilon) Test whether the ray with given origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the plane containing the given point (pointX, pointY, pointZ) and having the normal (normalX, normalY, normalZ), and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point.
static float	intersectRayPlane(Rayf ray, Planef plane, float epsilon) Test whether the given ray intersects the given plane, and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point.
static float	intersectRayPlane(org.joml.Vector3fc origin, org.joml.Vector3fc dir, org.joml.Vector3fc point, org.joml.Vector3fc normal, float epsilon) Test whether the ray with given origin and direction dir intersects the plane 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 boolean	intersectRaySphere(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float centerX, float centerY, float centerZ, float radiusSquared, org.joml.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	intersectRaySphere(Rayf ray, Spheref sphere, org.joml.Vector2f result) Test whether the given ray intersects the given sphere, 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	intersectRaySphere(org.joml.Vector3fc origin, org.joml.Vector3fc dir, org.joml.Vector3fc center, float radiusSquared, org.joml.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.
static float	intersectRayTriangle(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z, float epsilon) Determine whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z) and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection.
static float	intersectRayTriangle(org.joml.Vector3fc origin, org.joml.Vector3fc dir, org.joml.Vector3fc v0, org.joml.Vector3fc v1, org.joml.Vector3fc v2, float epsilon) Determine whether the ray with the given origin and the given dir intersects the triangle consisting of the three vertices v0, v1 and v2 and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection.
static float	intersectRayTriangleFront(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z, float epsilon) Determine whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the frontface of the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z) and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection.
static float	intersectRayTriangleFront(org.joml.Vector3fc origin, org.joml.Vector3fc dir, org.joml.Vector3fc v0, org.joml.Vector3fc v1, org.joml.Vector3fc v2, float epsilon) Determine whether the ray with the given origin and the given dir intersects the frontface of the triangle consisting of the three vertices v0, v1 and v2 and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection.
static boolean	intersectSphereSphere(float aX, float aY, float aZ, float radiusSquaredA, float bX, float bY, float bZ, float radiusSquaredB, org.joml.Vector4f centerAndRadiusOfIntersectionCircle) Test whether the one sphere with center (aX, aY, aZ) and square radius radiusSquaredA intersects the other sphere with center (bX, bY, bZ) and square radius radiusSquaredB, and store the center of the circle of intersection in the (x, y, z) components of the supplied vector and the radius of that circle in the w component.
static boolean	intersectSphereSphere(Spheref sphereA, Spheref sphereB, org.joml.Vector4f centerAndRadiusOfIntersectionCircle) Test whether the one sphere with intersects the other sphere, and store the center of the circle of intersection in the (x, y, z) components of the supplied vector and the radius of that circle in the w component.
static boolean	intersectSphereSphere(org.joml.Vector3fc centerA, float radiusSquaredA, org.joml.Vector3fc centerB, float radiusSquaredB, org.joml.Vector4f centerAndRadiusOfIntersectionCircle) Test whether the one sphere with center centerA and square radius radiusSquaredA intersects the other sphere with center centerB and square radius radiusSquaredB, and store the center of the circle of intersection in the (x, y, z) components of the supplied vector and the radius of that circle in the w component.
static int	intersectSphereTriangle(float sX, float sY, float sZ, float sR, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z, org.joml.Vector3f result) Test whether the given sphere with center (sX, sY, sZ) intersects the triangle given by its three vertices, and if they intersect store the point of intersection into result.
static int	intersectSweptSphereTriangle(float centerX, float centerY, float centerZ, float radius, float velX, float velY, float velZ, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z, float epsilon, float maxT, org.joml.Vector4f pointAndTime) Determine the point of intersection between a sphere with the given center (centerX, centerY, centerZ) and radius moving with the given velocity (velX, velY, velZ) and the triangle specified via its three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z), (v2X, v2Y, v2Z).
static boolean	testAabAab(AABBf aabb1, AABBf aabb2) Test whether the two axis-aligned boxes intersect.
static boolean	testAabAab(float minXA, float minYA, float minZA, float maxXA, float maxYA, float maxZA, float minXB, float minYB, float minZB, float maxXB, float maxYB, float maxZB) Test whether the axis-aligned box with minimum corner (minXA, minYA, minZA) and maximum corner (maxXA, maxYA, maxZA) intersects the axis-aligned box with minimum corner (minXB, minYB, minZB) and maximum corner (maxXB, maxYB, maxZB).
static boolean	testAabAab(org.joml.Vector3fc minA, org.joml.Vector3fc maxA, org.joml.Vector3fc minB, org.joml.Vector3fc maxB) Test whether the axis-aligned box with minimum corner minA and maximum corner maxA intersects the axis-aligned box with minimum corner minB and maximum corner maxB.
static boolean	testAabPlane(AABBf aabb, Planef plane) Test whether the axis-aligned box intersects the plane.
static boolean	testAabPlane(AABBi aabb, Planef plane) Test whether the axis-aligned box intersects the plane.
static boolean	testAabPlane(float minX, float minY, float minZ, float maxX, float maxY, float maxZ, float a, float b, float c, float d) Test whether the axis-aligned box with minimum corner (minX, minY, minZ) and maximum corner (maxX, maxY, maxZ) intersects the plane with the general equation a*x + b*y + c*z + d = 0.
static boolean	testAabPlane(org.joml.Vector3fc min, org.joml.Vector3fc max, float a, float b, float c, float d) Test whether the axis-aligned box with minimum corner min and maximum corner max intersects the plane with the general equation a*x + b*y + c*z + d = 0.
static boolean	testAabSphere(AABBf aabb, Spheref sphere) Test whether the given axis-aligned box intersects the given sphere.
static boolean	testAabSphere(AABBi aabb, Spheref sphere) Test whether the given axis-aligned box intersects the given sphere.
static boolean	testAabSphere(float minX, float minY, float minZ, float maxX, float maxY, float maxZ, float centerX, float centerY, float centerZ, float radiusSquared) Test whether the axis-aligned box with minimum corner (minX, minY, minZ) and maximum corner (maxX, maxY, maxZ) intersects the sphere with the given center (centerX, centerY, centerZ) and square radius radiusSquared.
static boolean	testAabSphere(org.joml.Vector3fc min, org.joml.Vector3fc max, org.joml.Vector3fc center, float radiusSquared) Test whether the axis-aligned box with minimum corner min and maximum corner max intersects the sphere with the given center and square radius radiusSquared.
static boolean	testAarAar(float minXA, float minYA, float maxXA, float maxYA, float minXB, float minYB, float maxXB, float maxYB) Test whether the axis-aligned rectangle with minimum corner (minXA, minYA) and maximum corner (maxXA, maxYA) intersects the axis-aligned rectangle with minimum corner (minXB, minYB) and maximum corner (maxXB, maxYB).
static boolean	testAarAar(org.joml.Vector2fc minA, org.joml.Vector2fc maxA, org.joml.Vector2fc minB, org.joml.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	testAarCircle(float minX, float minY, float maxX, float maxY, float centerX, float centerY, float radiusSquared) Test whether the axis-aligned rectangle with minimum corner (minX, minY) and maximum corner (maxX, maxY) intersects the circle with the given center (centerX, centerY) and square radius radiusSquared.
static boolean	testAarCircle(org.joml.Vector2fc min, org.joml.Vector2fc max, org.joml.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	testAarLine(float minX, float minY, float maxX, float maxY, float a, float b, float c) Test whether the axis-aligned rectangle with minimum corner (minX, minY) and maximum corner (maxX, maxY) intersects the line with the general equation a*x + b*y + c = 0.
static boolean	testAarLine(float minX, float minY, float maxX, float maxY, float x0, float y0, float x1, float y1) Test whether the axis-aligned rectangle with minimum corner (minX, minY) and maximum corner (maxX, maxY) intersects the line defined by the two points (x0, y0) and (x1, y1).
static boolean	testAarLine(org.joml.Vector2fc min, org.joml.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	testCircleCircle(float aX, float aY, float rA, float bX, float bY, float rB) Test whether the one circle with center (aX, aY) and radius rA intersects the other circle with center (bX, bY) and radius rB.
static boolean	testCircleCircle(org.joml.Vector2fc centerA, float radiusSquaredA, org.joml.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	testCircleTriangle(float centerX, float centerY, float radiusSquared, float v0X, float v0Y, float v1X, float v1Y, float v2X, float v2Y) Test whether the circle with center (centerX, centerY) and square radius radiusSquared intersects the triangle with counter-clockwise vertices (v0X, v0Y), (v1X, v1Y), (v2X, v2Y).
static boolean	testCircleTriangle(org.joml.Vector2fc center, float radiusSquared, org.joml.Vector2fc v0, org.joml.Vector2fc v1, org.joml.Vector2fc v2) Test whether the circle with given center and square radius radiusSquared intersects the triangle with counter-clockwise vertices v0, v1, v2.
static boolean	testLineCircle(float a, float b, float c, float centerX, float centerY, float radius) Test whether the line with the general line equation a*x + b*y + c = 0 intersects the circle with center (centerX, centerY) and radius.
static boolean	testLineSegmentSphere(float p0X, float p0Y, float p0Z, float p1X, float p1Y, float p1Z, float centerX, float centerY, float centerZ, float radiusSquared) Test whether the line segment with the end points (p0X, p0Y, p0Z) and (p1X, p1Y, p1Z) intersects the given sphere with center (centerX, centerY, centerZ) and square radius radiusSquared.
static boolean	testLineSegmentSphere(org.joml.Vector3fc p0, org.joml.Vector3fc p1, org.joml.Vector3fc center, float radiusSquared) Test whether the line segment with the end points p0 and p1 intersects the given sphere with center center and square radius radiusSquared.
static boolean	testLineSegmentTriangle(float p0X, float p0Y, float p0Z, float p1X, float p1Y, float p1Z, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z, float epsilon) Test whether the line segment with the end points (p0X, p0Y, p0Z) and (p1X, p1Y, p1Z) intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z), regardless of the winding order of the triangle or the direction of the line segment between its two end points.
static boolean	testLineSegmentTriangle(org.joml.Vector3fc p0, org.joml.Vector3fc p1, org.joml.Vector3fc v0, org.joml.Vector3fc v1, org.joml.Vector3fc v2, float epsilon) Test whether the line segment with the end points p0 and p1 intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z), regardless of the winding order of the triangle or the direction of the line segment between its two end points.
static boolean	testMovingCircleCircle(float aX, float aY, float maX, float maY, float aR, float bX, float bY, float bR) Test whether a given circle with center (aX, aY) and radius aR and travelled distance vector (maX, maY) intersects a given static circle with center (bX, bY) and radius bR.
static boolean	testMovingCircleCircle(org.joml.Vector2f centerA, org.joml.Vector2f moveA, float aR, org.joml.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	testObOb(float b0cX, float b0cY, float b0cZ, float b0uXx, float b0uXy, float b0uXz, float b0uYx, float b0uYy, float b0uYz, float b0uZx, float b0uZy, float b0uZz, float b0hsX, float b0hsY, float b0hsZ, float b1cX, float b1cY, float b1cZ, float b1uXx, float b1uXy, float b1uXz, float b1uYx, float b1uYy, float b1uYz, float b1uZx, float b1uZy, float b1uZz, float b1hsX, float b1hsY, float b1hsZ) Test whether two oriented boxes given via their center position, orientation and half-size, intersect.
static boolean	testObOb(org.joml.Vector3f b0c, org.joml.Vector3f b0uX, org.joml.Vector3f b0uY, org.joml.Vector3f b0uZ, org.joml.Vector3f b0hs, org.joml.Vector3f b1c, org.joml.Vector3f b1uX, org.joml.Vector3f b1uY, org.joml.Vector3f b1uZ, org.joml.Vector3f b1hs) Test whether two oriented boxes given via their center position, orientation and half-size, intersect.
static boolean	testPlaneSphere(float a, float b, float c, float d, float centerX, float centerY, float centerZ, float radius) Test whether the plane with the general plane equation a*x + b*y + c*z + d = 0 intersects the sphere with center (centerX, centerY, centerZ) and radius.
static boolean	testPlaneSphere(Planef plane, Spheref sphere) Test whether the given plane intersects the given sphere with center.
static boolean	testPlaneSweptSphere(float a, float b, float c, float d, float t0X, float t0Y, float t0Z, float r, float t1X, float t1Y, float t1Z) Test whether the plane with the general plane equation a*x + b*y + c*z + d = 0 intersects the sphere moving from center position (t0X, t0Y, t0Z) to (t1X, t1Y, t1Z) and having the given radius.
static boolean	testPointAar(float pX, float pY, float minX, float minY, float maxX, float maxY) Test whether the given point (pX, pY) lies inside the axis-aligned rectangle with the minimum corner (minX, minY) and maximum corner (maxX, maxY).
static boolean	testPointCircle(float pX, float pY, float centerX, float centerY, float radiusSquared) Test whether the point (pX, pY) lies inside the circle with center (centerX, centerY) and square radius radiusSquared.
static boolean	testPointInTriangle(float pX, float pY, float pZ, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z) Test whether the projection of the given point (pX, pY, pZ) lies inside of the triangle defined by the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z).
static boolean	testPointTriangle(float pX, float pY, float v0X, float v0Y, float v1X, float v1Y, float v2X, float v2Y) Test whether the given point (pX, pY) lies inside the triangle with the vertices (v0X, v0Y), (v1X, v1Y), (v2X, v2Y).
static boolean	testPointTriangle(org.joml.Vector2fc point, org.joml.Vector2fc v0, org.joml.Vector2fc v1, org.joml.Vector2fc v2) Test whether the given point lies inside the triangle with the vertices v0, v1, v2.
static boolean	testPolygonPolygon(org.joml.Vector2f[] v1s, org.joml.Vector2f[] v2s) Test if the two polygons, given via their vertices, intersect.
static boolean	testRayAab(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float minX, float minY, float minZ, float maxX, float maxY, float maxZ) 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).
static boolean	testRayAab(Rayf ray, AABBf aabb) Test whether the given ray intersects the given axis-aligned box.
static boolean	testRayAab(Rayf ray, AABBi aabb) Test whether the given ray intersects the given axis-aligned box.
static boolean	testRayAab(org.joml.Vector3fc origin, org.joml.Vector3fc dir, org.joml.Vector3fc min, org.joml.Vector3fc max) 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.
static boolean	testRayAar(float originX, float originY, float dirX, float dirY, float minX, float minY, float maxX, float maxY) Test whether the given ray with the origin (originX, originY) and direction (dirX, dirY) intersects the given axis-aligned rectangle given as its minimum corner (minX, minY) and maximum corner (maxX, maxY).
static boolean	testRayAar(org.joml.Vector2fc origin, org.joml.Vector2fc dir, org.joml.Vector2fc min, org.joml.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	testRayCircle(float originX, float originY, float dirX, float dirY, float centerX, float centerY, float radiusSquared) 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.
static boolean	testRayCircle(org.joml.Vector2fc origin, org.joml.Vector2fc dir, org.joml.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.
static boolean	testRaySphere(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float centerX, float centerY, float centerZ, float radiusSquared) 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.
static boolean	testRaySphere(Rayf ray, Spheref sphere) Test whether the given ray intersects the given sphere.
static boolean	testRaySphere(org.joml.Vector3fc origin, org.joml.Vector3fc dir, org.joml.Vector3fc center, float radiusSquared) Test whether the ray with the given origin and normalized direction dir intersects the sphere with the given center and square radius.
static boolean	testRayTriangle(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z, float epsilon) Test whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z).
static boolean	testRayTriangle(org.joml.Vector3fc origin, org.joml.Vector3fc dir, org.joml.Vector3fc v0, org.joml.Vector3fc v1, org.joml.Vector3fc v2, float epsilon) Test whether the ray with the given origin and the given dir intersects the frontface of the triangle consisting of the three vertices v0, v1 and v2.
static boolean	testRayTriangleFront(float originX, float originY, float originZ, float dirX, float dirY, float dirZ, float v0X, float v0Y, float v0Z, float v1X, float v1Y, float v1Z, float v2X, float v2Y, float v2Z, float epsilon) Test whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the frontface of the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z).
static boolean	testRayTriangleFront(org.joml.Vector3fc origin, org.joml.Vector3fc dir, org.joml.Vector3fc v0, org.joml.Vector3fc v1, org.joml.Vector3fc v2, float epsilon) Test whether the ray with the given origin and the given dir intersects the frontface of the triangle consisting of the three vertices v0, v1 and v2.
static boolean	testSphereSphere(float aX, float aY, float aZ, float radiusSquaredA, float bX, float bY, float bZ, float radiusSquaredB) Test whether the one sphere with center (aX, aY, aZ) and square radius radiusSquaredA intersects the other sphere with center (bX, bY, bZ) and square radius radiusSquaredB.
static boolean	testSphereSphere(org.joml.Vector3fc centerA, float radiusSquaredA, org.joml.Vector3fc centerB, float radiusSquaredB) Test whether the one sphere with center centerA and square radius radiusSquaredA intersects the other sphere with center centerB and square radius radiusSquaredB.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

POINT_ON_TRIANGLE_VERTEX_0

public static final int POINT_ON_TRIANGLE_VERTEX_0

Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point is the first vertex of the triangle.

See Also:

Constant Field Values

POINT_ON_TRIANGLE_VERTEX_1

public static final int POINT_ON_TRIANGLE_VERTEX_1

Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point is the second vertex of the triangle.

See Also:

Constant Field Values

POINT_ON_TRIANGLE_VERTEX_2

public static final int POINT_ON_TRIANGLE_VERTEX_2

Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point is the third vertex of the triangle.

See Also:

Constant Field Values

POINT_ON_TRIANGLE_EDGE_01

public static final int POINT_ON_TRIANGLE_EDGE_01

Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point lies on the edge between the first and second vertex of the triangle.

See Also:

Constant Field Values

POINT_ON_TRIANGLE_EDGE_12

public static final int POINT_ON_TRIANGLE_EDGE_12

Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point lies on the edge between the second and third vertex of the triangle.

See Also:

Constant Field Values

POINT_ON_TRIANGLE_EDGE_20

public static final int POINT_ON_TRIANGLE_EDGE_20

Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point lies on the edge between the third and first vertex of the triangle.

See Also:

Constant Field Values

POINT_ON_TRIANGLE_FACE

public static final int POINT_ON_TRIANGLE_FACE

Return value of findClosestPointOnTriangle(float, float, float, float, float, float, float, float, float, float, float, float, Vector3f), findClosestPointOnTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3f), findClosestPointOnTriangle(float, float, float, float, float, float, float, float, Vector2f) and findClosestPointOnTriangle(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) or intersectSweptSphereTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, org.joml.Vector4f) to signal that the closest point lies on the face of the triangle.

See Also:

Constant Field Values

AAR_SIDE_MINX

public static final int AAR_SIDE_MINX

Return value of intersectRayAar(float, float, float, float, float, float, float, float, Vector2f) and intersectRayAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the ray intersects the side of the axis-aligned rectangle with the minimum x coordinate.

See Also:

Constant Field Values

AAR_SIDE_MINY

public static final int AAR_SIDE_MINY

Return value of intersectRayAar(float, float, float, float, float, float, float, float, Vector2f) and intersectRayAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the ray intersects the side of the axis-aligned rectangle with the minimum y coordinate.

See Also:

Constant Field Values

AAR_SIDE_MAXX

public static final int AAR_SIDE_MAXX

Return value of intersectRayAar(float, float, float, float, float, float, float, float, Vector2f) and intersectRayAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the ray intersects the side of the axis-aligned rectangle with the maximum x coordinate.

See Also:

Constant Field Values

AAR_SIDE_MAXY

public static final int AAR_SIDE_MAXY

Return value of intersectRayAar(float, float, float, float, float, float, float, float, Vector2f) and intersectRayAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the ray intersects the side of the axis-aligned rectangle with the maximum y coordinate.

See Also:

Constant Field Values

OUTSIDE

public static final int OUTSIDE

Return value of intersectLineSegmentAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f) to indicate that the line segment does not intersect the axis-aligned box; or return value of intersectLineSegmentAar(float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the line segment does not intersect the axis-aligned rectangle.

See Also:

Constant Field Values

ONE_INTERSECTION

public static final int ONE_INTERSECTION

Return value of intersectLineSegmentAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f) to indicate that one end point of the line segment lies inside of the axis-aligned box; or return value of intersectLineSegmentAar(float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that one end point of the line segment lies inside of the axis-aligned rectangle.

See Also:

Constant Field Values

TWO_INTERSECTION

public static final int TWO_INTERSECTION

Return value of intersectLineSegmentAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f) to indicate that the line segment intersects two sides of the axis-aligned box or lies on an edge or a side of the box; or return value of intersectLineSegmentAar(float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the line segment intersects two edges of the axis-aligned rectangle or lies on an edge of the rectangle.

See Also:

Constant Field Values

INSIDE

public static final int INSIDE

Return value of intersectLineSegmentAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f) to indicate that the line segment lies completely inside of the axis-aligned box; or return value of intersectLineSegmentAar(float, float, float, float, float, float, float, float, Vector2f) and intersectLineSegmentAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f) to indicate that the line segment lies completely inside of the axis-aligned rectangle.

See Also:

Constant Field Values

Constructor Detail

Intersectionf

public Intersectionf()

Method Detail

testPlaneSphere

public static boolean testPlaneSphere(float a,
                                      float b,
                                      float c,
                                      float d,
                                      float centerX,
                                      float centerY,
                                      float centerZ,
                                      float radius)

Test whether the plane with the general plane equation a*x + b*y + c*z + d = 0 intersects the sphere with center (centerX, centerY, centerZ) and radius.

Reference: http://math.stackexchange.com

Parameters:

a - the x factor in the plane equation

b - the y factor in the plane equation

c - the z factor in the plane equation

d - the constant in the plane equation

centerX - the x coordinate of the sphere's center

centerY - the y coordinate of the sphere's center

centerZ - the z coordinate of the sphere's center

radius - the radius of the sphere

Returns:

true iff the plane intersects the sphere; false otherwise

testPlaneSphere

public static boolean testPlaneSphere(Planef plane,
                                      Spheref sphere)

Test whether the given plane intersects the given sphere with center.

Reference: http://math.stackexchange.com

Parameters:

plane - the plane

sphere - the sphere

Returns:

true iff the plane intersects the sphere; false otherwise

intersectPlaneSphere

public static boolean intersectPlaneSphere(float a,
                                           float b,
                                           float c,
                                           float d,
                                           float centerX,
                                           float centerY,
                                           float centerZ,
                                           float radius,
                                           org.joml.Vector4f intersectionCenterAndRadius)

Test whether the plane with the general plane equation a*x + b*y + c*z + d = 0 intersects the sphere with center (centerX, centerY, centerZ) and radius, and store the center of the circle of intersection in the (x, y, z) components of the supplied vector and the radius of that circle in the w component.

Reference: http://math.stackexchange.com

Parameters:

a - the x factor in the plane equation

b - the y factor in the plane equation

c - the z factor in the plane equation

d - the constant in the plane equation

centerX - the x coordinate of the sphere's center

centerY - the y coordinate of the sphere's center

centerZ - the z coordinate of the sphere's center

radius - the radius of the sphere

intersectionCenterAndRadius - will hold the center of the circle of intersection in the (x, y, z) components and the radius in the w component

Returns:

true iff the plane intersects the sphere; false otherwise

intersectPlaneSweptSphere

public static boolean intersectPlaneSweptSphere(float a,
                                                float b,
                                                float c,
                                                float d,
                                                float cX,
                                                float cY,
                                                float cZ,
                                                float radius,
                                                float vX,
                                                float vY,
                                                float vZ,
                                                org.joml.Vector4f pointAndTime)

Test whether the plane with the general plane equation a*x + b*y + c*z + d = 0 intersects the moving sphere with center (cX, cY, cZ), radius and velocity (vX, vY, vZ), and store the point of intersection in the (x, y, z) components of the supplied vector and the time of intersection in the w component.

The normal vector (a, b, c) of the plane equation needs to be normalized.

Reference: Book "Real-Time Collision Detection" chapter 5.5.3 "Intersecting Moving Sphere Against Plane"

Parameters:

a - the x factor in the plane equation

b - the y factor in the plane equation

c - the z factor in the plane equation

d - the constant in the plane equation

cX - the x coordinate of the center position of the sphere at t=0

cY - the y coordinate of the center position of the sphere at t=0

cZ - the z coordinate of the center position of the sphere at t=0

radius - the sphere's radius

vX - the x component of the velocity of the sphere

vY - the y component of the velocity of the sphere

vZ - the z component of the velocity of the sphere

pointAndTime - will hold the point and time of intersection (if any)

Returns:

true iff the sphere intersects the plane; false otherwise

testPlaneSweptSphere

public static boolean testPlaneSweptSphere(float a,
                                           float b,
                                           float c,
                                           float d,
                                           float t0X,
                                           float t0Y,
                                           float t0Z,
                                           float r,
                                           float t1X,
                                           float t1Y,
                                           float t1Z)

Test whether the plane with the general plane equation a*x + b*y + c*z + d = 0 intersects the sphere moving from center position (t0X, t0Y, t0Z) to (t1X, t1Y, t1Z) and having the given radius.

The normal vector (a, b, c) of the plane equation needs to be normalized.

Reference: Book "Real-Time Collision Detection" chapter 5.5.3 "Intersecting Moving Sphere Against Plane"

Parameters:

a - the x factor in the plane equation

b - the y factor in the plane equation

c - the z factor in the plane equation

d - the constant in the plane equation

t0X - the x coordinate of the start position of the sphere

t0Y - the y coordinate of the start position of the sphere

t0Z - the z coordinate of the start position of the sphere

r - the sphere's radius

t1X - the x coordinate of the end position of the sphere

t1Y - the y coordinate of the end position of the sphere

t1Z - the z coordinate of the end position of the sphere

Returns:

true if the sphere intersects the plane; false otherwise

testAabPlane

public static boolean testAabPlane(float minX,
                                   float minY,
                                   float minZ,
                                   float maxX,
                                   float maxY,
                                   float maxZ,
                                   float a,
                                   float b,
                                   float c,
                                   float d)

Test whether the axis-aligned box with minimum corner (minX, minY, minZ) and maximum corner (maxX, maxY, maxZ) intersects the plane with the general equation a*x + b*y + c*z + d = 0.

Reference: http://www.lighthouse3d.com ("Geometric Approach - Testing Boxes II")

Parameters:

minX - the x coordinate of the minimum corner of the axis-aligned box

minY - the y coordinate of the minimum corner of the axis-aligned box

minZ - the z coordinate of the minimum corner of the axis-aligned box

maxX - the x coordinate of the maximum corner of the axis-aligned box

maxY - the y coordinate of the maximum corner of the axis-aligned box

maxZ - the z coordinate of the maximum corner of the axis-aligned box

a - the x factor in the plane equation

b - the y factor in the plane equation

c - the z factor in the plane equation

d - the constant in the plane equation

Returns:

true iff the axis-aligned box intersects the plane; false otherwise

testAabPlane

public static boolean testAabPlane(AABBf aabb,
                                   Planef plane)

Test whether the axis-aligned box intersects the plane.

Reference: http://www.lighthouse3d.com ("Geometric Approach - Testing Boxes II")

Parameters:

aabb - the AABB

plane - the plane

Returns:

true iff the axis-aligned box intersects the plane; false otherwise

testAabPlane

public static boolean testAabPlane(AABBi aabb,
                                   Planef plane)

Test whether the axis-aligned box intersects the plane.

Reference: http://www.lighthouse3d.com ("Geometric Approach - Testing Boxes II")

Parameters:

aabb - the AABB

plane - the plane

Returns:

true iff the axis-aligned box intersects the plane; false otherwise

testAabPlane

public static boolean testAabPlane(org.joml.Vector3fc min,
                                   org.joml.Vector3fc max,
                                   float a,
                                   float b,
                                   float c,
                                   float d)

Test whether the axis-aligned box with minimum corner min and maximum corner max intersects the plane with the general equation a*x + b*y + c*z + d = 0.

Reference: http://www.lighthouse3d.com ("Geometric Approach - Testing Boxes II")

Parameters:

min - the minimum corner of the axis-aligned box

max - the maximum corner of the axis-aligned box

a - the x factor in the plane equation

b - the y factor in the plane equation

c - the z factor in the plane equation

d - the constant in the plane equation

Returns:

true iff the axis-aligned box intersects the plane; false otherwise

testAabAab

public static boolean testAabAab(float minXA,
                                 float minYA,
                                 float minZA,
                                 float maxXA,
                                 float maxYA,
                                 float maxZA,
                                 float minXB,
                                 float minYB,
                                 float minZB,
                                 float maxXB,
                                 float maxYB,
                                 float maxZB)

Test whether the axis-aligned box with minimum corner (minXA, minYA, minZA) and maximum corner (maxXA, maxYA, maxZA) intersects the axis-aligned box with minimum corner (minXB, minYB, minZB) and maximum corner (maxXB, maxYB, maxZB).

Parameters:

minXA - the x coordinate of the minimum corner of the first axis-aligned box

minYA - the y coordinate of the minimum corner of the first axis-aligned box

minZA - the z coordinate of the minimum corner of the first axis-aligned box

maxXA - the x coordinate of the maximum corner of the first axis-aligned box

maxYA - the y coordinate of the maximum corner of the first axis-aligned box

maxZA - the z coordinate of the maximum corner of the first axis-aligned box

minXB - the x coordinate of the minimum corner of the second axis-aligned box

minYB - the y coordinate of the minimum corner of the second axis-aligned box

minZB - the z coordinate of the minimum corner of the second axis-aligned box

maxXB - the x coordinate of the maximum corner of the second axis-aligned box

maxYB - the y coordinate of the maximum corner of the second axis-aligned box

maxZB - the z coordinate of the maximum corner of the second axis-aligned box

Returns:

true iff both axis-aligned boxes intersect; false otherwise

testAabAab

public static boolean testAabAab(org.joml.Vector3fc minA,
                                 org.joml.Vector3fc maxA,
                                 org.joml.Vector3fc minB,
                                 org.joml.Vector3fc maxB)

Test whether the axis-aligned box with minimum corner minA and maximum corner maxA intersects the axis-aligned box with minimum corner minB and maximum corner maxB.

Parameters:

minA - the minimum corner of the first axis-aligned box

maxA - the maximum corner of the first axis-aligned box

minB - the minimum corner of the second axis-aligned box

maxB - the maximum corner of the second axis-aligned box

Returns:

true iff both axis-aligned boxes intersect; false otherwise

testAabAab

public static boolean testAabAab(AABBf aabb1,
                                 AABBf aabb2)

Test whether the two axis-aligned boxes intersect.

Parameters:

aabb1 - the first AABB

aabb2 - the second AABB

Returns:

true iff both axis-aligned boxes intersect; false otherwise

testObOb

public static boolean testObOb(org.joml.Vector3f b0c,
                               org.joml.Vector3f b0uX,
                               org.joml.Vector3f b0uY,
                               org.joml.Vector3f b0uZ,
                               org.joml.Vector3f b0hs,
                               org.joml.Vector3f b1c,
                               org.joml.Vector3f b1uX,
                               org.joml.Vector3f b1uY,
                               org.joml.Vector3f b1uZ,
                               org.joml.Vector3f b1hs)

Test whether two oriented boxes given via their center position, orientation and half-size, intersect.

The orientation of a box is given as three unit vectors spanning the local orthonormal basis of the box.

The size is given as the half-size along each of the unit vectors defining the orthonormal basis.

Reference: Book "Real-Time Collision Detection" chapter 4.4.1 "OBB-OBB Intersection"

Parameters:

b0c - the center of the first box

b0uX - the local X unit vector of the first box

b0uY - the local Y unit vector of the first box

b0uZ - the local Z unit vector of the first box

b0hs - the half-size of the first box

b1c - the center of the second box

b1uX - the local X unit vector of the second box

b1uY - the local Y unit vector of the second box

b1uZ - the local Z unit vector of the second box

b1hs - the half-size of the second box

Returns:

true if both boxes intersect; false otherwise

testObOb

public static boolean testObOb(float b0cX,
                               float b0cY,
                               float b0cZ,
                               float b0uXx,
                               float b0uXy,
                               float b0uXz,
                               float b0uYx,
                               float b0uYy,
                               float b0uYz,
                               float b0uZx,
                               float b0uZy,
                               float b0uZz,
                               float b0hsX,
                               float b0hsY,
                               float b0hsZ,
                               float b1cX,
                               float b1cY,
                               float b1cZ,
                               float b1uXx,
                               float b1uXy,
                               float b1uXz,
                               float b1uYx,
                               float b1uYy,
                               float b1uYz,
                               float b1uZx,
                               float b1uZy,
                               float b1uZz,
                               float b1hsX,
                               float b1hsY,
                               float b1hsZ)

Test whether two oriented boxes given via their center position, orientation and half-size, intersect.

The orientation of a box is given as three unit vectors spanning the local orthonormal basis of the box.

The size is given as the half-size along each of the unit vectors defining the orthonormal basis.

Reference: Book "Real-Time Collision Detection" chapter 4.4.1 "OBB-OBB Intersection"

Parameters:

b0cX - the x coordinate of the center of the first box

b0cY - the y coordinate of the center of the first box

b0cZ - the z coordinate of the center of the first box

b0uXx - the x coordinate of the local X unit vector of the first box

b0uXy - the y coordinate of the local X unit vector of the first box

b0uXz - the z coordinate of the local X unit vector of the first box

b0uYx - the x coordinate of the local Y unit vector of the first box

b0uYy - the y coordinate of the local Y unit vector of the first box

b0uYz - the z coordinate of the local Y unit vector of the first box

b0uZx - the x coordinate of the local Z unit vector of the first box

b0uZy - the y coordinate of the local Z unit vector of the first box

b0uZz - the z coordinate of the local Z unit vector of the first box

b0hsX - the half-size of the first box along its local X axis

b0hsY - the half-size of the first box along its local Y axis

b0hsZ - the half-size of the first box along its local Z axis

b1cX - the x coordinate of the center of the second box

b1cY - the y coordinate of the center of the second box

b1cZ - the z coordinate of the center of the second box

b1uXx - the x coordinate of the local X unit vector of the second box

b1uXy - the y coordinate of the local X unit vector of the second box

b1uXz - the z coordinate of the local X unit vector of the second box

b1uYx - the x coordinate of the local Y unit vector of the second box

b1uYy - the y coordinate of the local Y unit vector of the second box

b1uYz - the z coordinate of the local Y unit vector of the second box

b1uZx - the x coordinate of the local Z unit vector of the second box

b1uZy - the y coordinate of the local Z unit vector of the second box

b1uZz - the z coordinate of the local Z unit vector of the second box

b1hsX - the half-size of the second box along its local X axis

b1hsY - the half-size of the second box along its local Y axis

b1hsZ - the half-size of the second box along its local Z axis

Returns:

true if both boxes intersect; false otherwise

intersectSphereSphere

public static boolean intersectSphereSphere(float aX,
                                            float aY,
                                            float aZ,
                                            float radiusSquaredA,
                                            float bX,
                                            float bY,
                                            float bZ,
                                            float radiusSquaredB,
                                            org.joml.Vector4f centerAndRadiusOfIntersectionCircle)

Test whether the one sphere with center (aX, aY, aZ) and square radius radiusSquaredA intersects the other sphere with center (bX, bY, bZ) and square radius radiusSquaredB, and store the center of the circle of intersection in the (x, y, z) components of the supplied vector and the radius of that circle in the w component.

The normal vector of the circle of intersection can simply be obtained by subtracting the center of either sphere from the other.

Reference: http://gamedev.stackexchange.com

Parameters:

aX - the x coordinate of the first sphere's center

aY - the y coordinate of the first sphere's center

aZ - the z coordinate of the first sphere's center

radiusSquaredA - the square of the first sphere's radius

bX - the x coordinate of the second sphere's center

bY - the y coordinate of the second sphere's center

bZ - the z coordinate of the second sphere's center

radiusSquaredB - the square of the second sphere's radius

centerAndRadiusOfIntersectionCircle - will hold the center of the circle of intersection in the (x, y, z) components and the radius in the w component

Returns:

true iff both spheres intersect; false otherwise

intersectSphereSphere

public static boolean intersectSphereSphere(org.joml.Vector3fc centerA,
                                            float radiusSquaredA,
                                            org.joml.Vector3fc centerB,
                                            float radiusSquaredB,
                                            org.joml.Vector4f centerAndRadiusOfIntersectionCircle)

Test whether the one sphere with center centerA and square radius radiusSquaredA intersects the other sphere with center centerB and square radius radiusSquaredB, and store the center of the circle of intersection in the (x, y, z) components of the supplied vector and the radius of that circle in the w component.

The normal vector of the circle of intersection can simply be obtained by subtracting the center of either sphere from the other.

Reference: http://gamedev.stackexchange.com

Parameters:

centerA - the first sphere's center

radiusSquaredA - the square of the first sphere's radius

centerB - the second sphere's center

radiusSquaredB - the square of the second sphere's radius

centerAndRadiusOfIntersectionCircle - will hold the center of the circle of intersection in the (x, y, z) components and the radius in the w component

Returns:

true iff both spheres intersect; false otherwise

intersectSphereSphere

public static boolean intersectSphereSphere(Spheref sphereA,
                                            Spheref sphereB,
                                            org.joml.Vector4f centerAndRadiusOfIntersectionCircle)

Test whether the one sphere with intersects the other sphere, and store the center of the circle of intersection in the (x, y, z) components of the supplied vector and the radius of that circle in the w component.

The normal vector of the circle of intersection can simply be obtained by subtracting the center of either sphere from the other.

Reference: http://gamedev.stackexchange.com

Parameters:

sphereA - the first sphere

sphereB - the second sphere

centerAndRadiusOfIntersectionCircle - will hold the center of the circle of intersection in the (x, y, z) components and the radius in the w component

Returns:

true iff both spheres intersect; false otherwise

intersectSphereTriangle

public static int intersectSphereTriangle(float sX,
                                          float sY,
                                          float sZ,
                                          float sR,
                                          float v0X,
                                          float v0Y,
                                          float v0Z,
                                          float v1X,
                                          float v1Y,
                                          float v1Z,
                                          float v2X,
                                          float v2Y,
                                          float v2Z,
                                          org.joml.Vector3f result)

Test whether the given sphere with center (sX, sY, sZ) intersects the triangle given by its three vertices, and if they intersect store the point of intersection into result.

This method also returns whether the point of intersection is on one of the triangle's vertices, edges or on the face.

Reference: Book "Real-Time Collision Detection" chapter 5.2.7 "Testing Sphere Against Triangle"

Parameters:

sX - the x coordinate of the sphere's center

sY - the y coordinate of the sphere's center

sZ - the z coordinate of the sphere's center

sR - the sphere's radius

v0X - the x coordinate of the first vertex of the triangle

v0Y - the y coordinate of the first vertex of the triangle

v0Z - the z coordinate of the first vertex of the triangle

v1X - the x coordinate of the second vertex of the triangle

v1Y - the y coordinate of the second vertex of the triangle

v1Z - the z coordinate of the second vertex of the triangle

v2X - the x coordinate of the third vertex of the triangle

v2Y - the y coordinate of the third vertex of the triangle

v2Z - the z coordinate of the third vertex of the triangle

result - will hold the point of intersection

Returns:

one of POINT_ON_TRIANGLE_VERTEX_0, POINT_ON_TRIANGLE_VERTEX_1, POINT_ON_TRIANGLE_VERTEX_2, POINT_ON_TRIANGLE_EDGE_01, POINT_ON_TRIANGLE_EDGE_12, POINT_ON_TRIANGLE_EDGE_20 or POINT_ON_TRIANGLE_FACE or 0

testSphereSphere

public static boolean testSphereSphere(float aX,
                                       float aY,
                                       float aZ,
                                       float radiusSquaredA,
                                       float bX,
                                       float bY,
                                       float bZ,
                                       float radiusSquaredB)

Test whether the one sphere with center (aX, aY, aZ) and square radius radiusSquaredA intersects the other sphere with center (bX, bY, bZ) and square radius radiusSquaredB.

Reference: http://gamedev.stackexchange.com

Parameters:

aX - the x coordinate of the first sphere's center

aY - the y coordinate of the first sphere's center

aZ - the z coordinate of the first sphere's center

radiusSquaredA - the square of the first sphere's radius

bX - the x coordinate of the second sphere's center

bY - the y coordinate of the second sphere's center

bZ - the z coordinate of the second sphere's center

radiusSquaredB - the square of the second sphere's radius

Returns:

true iff both spheres intersect; false otherwise

testSphereSphere

public static boolean testSphereSphere(org.joml.Vector3fc centerA,
                                       float radiusSquaredA,
                                       org.joml.Vector3fc centerB,
                                       float radiusSquaredB)

Test whether the one sphere with center centerA and square radius radiusSquaredA intersects the other sphere with center centerB and square radius radiusSquaredB.

Reference: http://gamedev.stackexchange.com

Parameters:

centerA - the first sphere's center

radiusSquaredA - the square of the first sphere's radius

centerB - the second sphere's center

radiusSquaredB - the square of the second sphere's radius

Returns:

true iff both spheres intersect; false otherwise

distancePointPlane

public static float distancePointPlane(float pointX,
                                       float pointY,
                                       float pointZ,
                                       float a,
                                       float b,
                                       float c,
                                       float d)

Determine the signed distance of the given point (pointX, pointY, pointZ) to the plane specified via its general plane equation a*x + b*y + c*z + d = 0.

Parameters:

pointX - the x coordinate of the point

pointY - the y coordinate of the point

pointZ - the z coordinate of the point

a - the x factor in the plane equation

b - the y factor in the plane equation

c - the z factor in the plane equation

d - the constant in the plane equation

Returns:

the distance between the point and the plane

distancePointPlane

public static float distancePointPlane(float pointX,
                                       float pointY,
                                       float pointZ,
                                       float v0X,
                                       float v0Y,
                                       float v0Z,
                                       float v1X,
                                       float v1Y,
                                       float v1Z,
                                       float v2X,
                                       float v2Y,
                                       float v2Z)

Determine the signed distance of the given point (pointX, pointY, pointZ) to the plane of the triangle specified by its three points (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z).

If the point lies on the front-facing side of the triangle's plane, that is, if the triangle has counter-clockwise winding order as seen from the point, then this method returns a positive number.

Parameters:

pointX - the x coordinate of the point

pointY - the y coordinate of the point

pointZ - the z coordinate of the point

v0X - the x coordinate of the first vertex of the triangle

v0Y - the y coordinate of the first vertex of the triangle

v0Z - the z coordinate of the first vertex of the triangle

v1X - the x coordinate of the second vertex of the triangle

v1Y - the y coordinate of the second vertex of the triangle

v1Z - the z coordinate of the second vertex of the triangle

v2X - the x coordinate of the third vertex of the triangle

v2Y - the y coordinate of the third vertex of the triangle

v2Z - the z coordinate of the third vertex of the triangle

Returns:

the signed distance between the point and the plane of the triangle

intersectRayPlane

public static float intersectRayPlane(float originX,
                                      float originY,
                                      float originZ,
                                      float dirX,
                                      float dirY,
                                      float dirZ,
                                      float pointX,
                                      float pointY,
                                      float pointZ,
                                      float normalX,
                                      float normalY,
                                      float normalZ,
                                      float epsilon)

Test whether the ray with given origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the plane containing the given point (pointX, pointY, pointZ) and having the normal (normalX, normalY, normalZ), and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point.

This method returns -1.0 if the ray does not intersect the plane, because it is either parallel to the plane or its direction points away from the plane or the ray's origin is on the negative side of the plane (i.e. the plane's normal points away from the ray's origin).

Reference: https://www.siggraph.org/

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

originZ - the z coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

dirZ - the z coordinate of the ray's direction

pointX - the x coordinate of a point on the plane

pointY - the y coordinate of a point on the plane

pointZ - the z coordinate of a point on the plane

normalX - the x coordinate of the plane's normal

normalY - the y coordinate of the plane's normal

normalZ - the z coordinate of the plane's normal

epsilon - some small epsilon for when the ray is parallel to the plane

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if the ray intersects the plane; -1.0 otherwise

intersectRayPlane

public static float intersectRayPlane(org.joml.Vector3fc origin,
                                      org.joml.Vector3fc dir,
                                      org.joml.Vector3fc point,
                                      org.joml.Vector3fc normal,
                                      float epsilon)

Test whether the ray with given origin and direction dir intersects the plane 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.

This method returns -1.0 if the ray does not intersect the plane, because it is either parallel to the plane or its direction points away from the plane or the ray's origin is on the negative side of the plane (i.e. the plane's normal points away from the ray's origin).

Reference: https://www.siggraph.org/

Parameters:

origin - the ray's origin

dir - the ray's direction

point - a point on the plane

normal - the plane's normal

epsilon - some small epsilon for when the ray is parallel to the plane

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if the ray intersects the plane; -1.0 otherwise

intersectRayPlane

public static float intersectRayPlane(Rayf ray,
                                      Planef plane,
                                      float epsilon)

Test whether the given ray intersects the given plane, and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point.

This method returns -1.0 if the ray does not intersect the plane, because it is either parallel to the plane or its direction points away from the plane or the ray's origin is on the negative side of the plane (i.e. the plane's normal points away from the ray's origin).

Reference: https://www.siggraph.org/

Parameters:

ray - the ray

plane - the plane

epsilon - some small epsilon for when the ray is parallel to the plane

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if the ray intersects the plane; -1.0 otherwise

intersectRayPlane

public static float intersectRayPlane(float originX,
                                      float originY,
                                      float originZ,
                                      float dirX,
                                      float dirY,
                                      float dirZ,
                                      float a,
                                      float b,
                                      float c,
                                      float d,
                                      float epsilon)

Test whether the ray with given origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the plane given as the general plane equation a*x + b*y + c*z + d = 0, and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point.

This method returns -1.0 if the ray does not intersect the plane, because it is either parallel to the plane or its direction points away from the plane or the ray's origin is on the negative side of the plane (i.e. the plane's normal points away from the ray's origin).

Reference: https://www.siggraph.org/

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

originZ - the z coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

dirZ - the z coordinate of the ray's direction

a - the x factor in the plane equation

b - the y factor in the plane equation

c - the z factor in the plane equation

d - the constant in the plane equation

epsilon - some small epsilon for when the ray is parallel to the plane

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if the ray intersects the plane; -1.0 otherwise

testAabSphere

public static boolean testAabSphere(float minX,
                                    float minY,
                                    float minZ,
                                    float maxX,
                                    float maxY,
                                    float maxZ,
                                    float centerX,
                                    float centerY,
                                    float centerZ,
                                    float radiusSquared)

Test whether the axis-aligned box with minimum corner (minX, minY, minZ) and maximum corner (maxX, maxY, maxZ) intersects the sphere with the given center (centerX, centerY, centerZ) and square radius radiusSquared.

Reference: http://stackoverflow.com

Parameters:

minX - the x coordinate of the minimum corner of the axis-aligned box

minY - the y coordinate of the minimum corner of the axis-aligned box

minZ - the z coordinate of the minimum corner of the axis-aligned box

maxX - the x coordinate of the maximum corner of the axis-aligned box

maxY - the y coordinate of the maximum corner of the axis-aligned box

maxZ - the z coordinate of the maximum corner of the axis-aligned box

centerX - the x coordinate of the sphere's center

centerY - the y coordinate of the sphere's center

centerZ - the z coordinate of the sphere's center

radiusSquared - the square of the sphere's radius

Returns:

true iff the axis-aligned box intersects the sphere; false otherwise

testAabSphere

public static boolean testAabSphere(org.joml.Vector3fc min,
                                    org.joml.Vector3fc max,
                                    org.joml.Vector3fc center,
                                    float radiusSquared)

Test whether the axis-aligned box with minimum corner min and maximum corner max intersects the sphere with the given center and square radius radiusSquared.

Reference: http://stackoverflow.com

Parameters:

min - the minimum corner of the axis-aligned box

max - the maximum corner of the axis-aligned box

center - the sphere's center

radiusSquared - the squared of the sphere's radius

Returns:

true iff the axis-aligned box intersects the sphere; false otherwise

testAabSphere

public static boolean testAabSphere(AABBf aabb,
                                    Spheref sphere)

Test whether the given axis-aligned box intersects the given sphere.

Reference: http://stackoverflow.com

Parameters:

aabb - the AABB

sphere - the sphere

Returns:

true iff the axis-aligned box intersects the sphere; false otherwise

testAabSphere

public static boolean testAabSphere(AABBi aabb,
                                    Spheref sphere)

Test whether the given axis-aligned box intersects the given sphere.

Reference: http://stackoverflow.com

Parameters:

aabb - the AABB

sphere - the sphere

Returns:

true iff the axis-aligned box intersects the sphere; false otherwise

findClosestPointOnPlane

public static org.joml.Vector3f findClosestPointOnPlane(float aX,
                                                        float aY,
                                                        float aZ,
                                                        float nX,
                                                        float nY,
                                                        float nZ,
                                                        float pX,
                                                        float pY,
                                                        float pZ,
                                                        org.joml.Vector3f result)

Find the point on the given plane which is closest to the specified point (pX, pY, pZ) and store the result in result.

Parameters:

aX - the x coordinate of one point on the plane

aY - the y coordinate of one point on the plane

aZ - the z coordinate of one point on the plane

nX - the x coordinate of the unit normal of the plane

nY - the y coordinate of the unit normal of the plane

nZ - the z coordinate of the unit normal of the plane

pX - the x coordinate of the point

pY - the y coordinate of the point

pZ - the z coordinate of the point

result - will hold the result

Returns:

result

findClosestPointOnLineSegment

public static org.joml.Vector3f findClosestPointOnLineSegment(float aX,
                                                              float aY,
                                                              float aZ,
                                                              float bX,
                                                              float bY,
                                                              float bZ,
                                                              float pX,
                                                              float pY,
                                                              float pZ,
                                                              org.joml.Vector3f result)

Find the point on the given line segment which is closest to the specified point (pX, pY, pZ), and store the result in result.

Parameters:

aX - the x coordinate of the first end point of the line segment

aY - the y coordinate of the first end point of the line segment

aZ - the z coordinate of the first end point of the line segment

bX - the x coordinate of the second end point of the line segment

bY - the y coordinate of the second end point of the line segment

bZ - the z coordinate of the second end point of the line segment

pX - the x coordinate of the point

pY - the y coordinate of the point

pZ - the z coordinate of the point

result - will hold the result

Returns:

result

findClosestPointsLineSegments

public static float findClosestPointsLineSegments(float a0X,
                                                  float a0Y,
                                                  float a0Z,
                                                  float a1X,
                                                  float a1Y,
                                                  float a1Z,
                                                  float b0X,
                                                  float b0Y,
                                                  float b0Z,
                                                  float b1X,
                                                  float b1Y,
                                                  float b1Z,
                                                  org.joml.Vector3f resultA,
                                                  org.joml.Vector3f resultB)

Find the closest points on the two line segments, store the point on the first line segment in resultA and the point on the second line segment in resultB, and return the square distance between both points.

Reference: Book "Real-Time Collision Detection" chapter 5.1.9 "Closest Points of Two Line Segments"

Parameters:

a0X - the x coordinate of the first line segment's first end point

a0Y - the y coordinate of the first line segment's first end point

a0Z - the z coordinate of the first line segment's first end point

a1X - the x coordinate of the first line segment's second end point

a1Y - the y coordinate of the first line segment's second end point

a1Z - the z coordinate of the first line segment's second end point

b0X - the x coordinate of the second line segment's first end point

b0Y - the y coordinate of the second line segment's first end point

b0Z - the z coordinate of the second line segment's first end point

b1X - the x coordinate of the second line segment's second end point

b1Y - the y coordinate of the second line segment's second end point

b1Z - the z coordinate of the second line segment's second end point

resultA - will hold the point on the first line segment

resultB - will hold the point on the second line segment

Returns:

the square distance between the two closest points

findClosestPointsLineSegmentTriangle

public static float findClosestPointsLineSegmentTriangle(float aX,
                                                         float aY,
                                                         float aZ,
                                                         float bX,
                                                         float bY,
                                                         float bZ,
                                                         float v0X,
                                                         float v0Y,
                                                         float v0Z,
                                                         float v1X,
                                                         float v1Y,
                                                         float v1Z,
                                                         float v2X,
                                                         float v2Y,
                                                         float v2Z,
                                                         org.joml.Vector3f lineSegmentResult,
                                                         org.joml.Vector3f triangleResult)

Find the closest points on a line segment and a triangle.

Reference: Book "Real-Time Collision Detection" chapter 5.1.10 "Closest Points of a Line Segment and a Triangle"

Parameters:

aX - the x coordinate of the line segment's first end point

aY - the y coordinate of the line segment's first end point

aZ - the z coordinate of the line segment's first end point

bX - the x coordinate of the line segment's second end point

bY - the y coordinate of the line segment's second end point

bZ - the z coordinate of the line segment's second end point

v0X - the x coordinate of the triangle's first vertex

v0Y - the y coordinate of the triangle's first vertex

v0Z - the z coordinate of the triangle's first vertex

v1X - the x coordinate of the triangle's second vertex

v1Y - the y coordinate of the triangle's second vertex

v1Z - the z coordinate of the triangle's second vertex

v2X - the x coordinate of the triangle's third vertex

v2Y - the y coordinate of the triangle's third vertex

v2Z - the z coordinate of the triangle's third vertex

lineSegmentResult - will hold the closest point on the line segment

triangleResult - will hold the closest point on the triangle

Returns:

the square distance of the closest points

findClosestPointOnTriangle

public static int findClosestPointOnTriangle(float v0X,
                                             float v0Y,
                                             float v0Z,
                                             float v1X,
                                             float v1Y,
                                             float v1Z,
                                             float v2X,
                                             float v2Y,
                                             float v2Z,
                                             float pX,
                                             float pY,
                                             float pZ,
                                             org.joml.Vector3f result)

Determine the closest point on the triangle with the given vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z), (v2X, v2Y, v2Z) between that triangle and the given point (pX, pY, pZ) and store that point into the given result.

Additionally, this method returns whether the closest point is a vertex (POINT_ON_TRIANGLE_VERTEX_0, POINT_ON_TRIANGLE_VERTEX_1, POINT_ON_TRIANGLE_VERTEX_2) of the triangle, lies on an edge (POINT_ON_TRIANGLE_EDGE_01, POINT_ON_TRIANGLE_EDGE_12, POINT_ON_TRIANGLE_EDGE_20) or on the face of the triangle.

Reference: Book "Real-Time Collision Detection" chapter 5.1.5 "Closest Point on Triangle to Point"

Parameters:

v0X - the x coordinate of the first vertex of the triangle

v0Y - the y coordinate of the first vertex of the triangle

v0Z - the z coordinate of the first vertex of the triangle

v1X - the x coordinate of the second vertex of the triangle

v1Y - the y coordinate of the second vertex of the triangle

v1Z - the z coordinate of the second vertex of the triangle

v2X - the x coordinate of the third vertex of the triangle

v2Y - the y coordinate of the third vertex of the triangle

v2Z - the z coordinate of the third vertex of the triangle

pX - the x coordinate of the point

pY - the y coordinate of the point

pZ - the y coordinate of the point

result - will hold the closest point

Returns:

one of POINT_ON_TRIANGLE_VERTEX_0, POINT_ON_TRIANGLE_VERTEX_1, POINT_ON_TRIANGLE_VERTEX_2, POINT_ON_TRIANGLE_EDGE_01, POINT_ON_TRIANGLE_EDGE_12, POINT_ON_TRIANGLE_EDGE_20 or POINT_ON_TRIANGLE_FACE

findClosestPointOnTriangle

public static int findClosestPointOnTriangle(org.joml.Vector3fc v0,
                                             org.joml.Vector3fc v1,
                                             org.joml.Vector3fc v2,
                                             org.joml.Vector3fc p,
                                             org.joml.Vector3f 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.

Additionally, this method returns whether the closest point is a vertex (POINT_ON_TRIANGLE_VERTEX_0, POINT_ON_TRIANGLE_VERTEX_1, POINT_ON_TRIANGLE_VERTEX_2) of the triangle, lies on an edge (POINT_ON_TRIANGLE_EDGE_01, POINT_ON_TRIANGLE_EDGE_12, POINT_ON_TRIANGLE_EDGE_20) or on the face of the triangle.

Reference: Book "Real-Time Collision Detection" chapter 5.1.5 "Closest Point on Triangle to Point"

Parameters:

v0 - the first vertex of the triangle

v1 - the second vertex of the triangle

v2 - the third vertex of the triangle

p - the point

result - will hold the closest point

Returns:

one of POINT_ON_TRIANGLE_VERTEX_0, POINT_ON_TRIANGLE_VERTEX_1, POINT_ON_TRIANGLE_VERTEX_2, POINT_ON_TRIANGLE_EDGE_01, POINT_ON_TRIANGLE_EDGE_12, POINT_ON_TRIANGLE_EDGE_20 or POINT_ON_TRIANGLE_FACE

findClosestPointOnRectangle

public static org.joml.Vector3f findClosestPointOnRectangle(float aX,
                                                            float aY,
                                                            float aZ,
                                                            float bX,
                                                            float bY,
                                                            float bZ,
                                                            float cX,
                                                            float cY,
                                                            float cZ,
                                                            float pX,
                                                            float pY,
                                                            float pZ,
                                                            org.joml.Vector3f res)

Find the point on a given rectangle, specified via three of its corners, which is closest to the specified point (pX, pY, pZ) and store the result into res.

Reference: Book "Real-Time Collision Detection" chapter 5.1.4.2 "Closest Point on 3D Rectangle to Point"

Parameters:

aX - the x coordinate of the first corner point of the rectangle

aY - the y coordinate of the first corner point of the rectangle

aZ - the z coordinate of the first corner point of the rectangle

bX - the x coordinate of the second corner point of the rectangle

bY - the y coordinate of the second corner point of the rectangle

bZ - the z coordinate of the second corner point of the rectangle

cX - the x coordinate of the third corner point of the rectangle

cY - the y coordinate of the third corner point of the rectangle

cZ - the z coordinate of the third corner point of the rectangle

pX - the x coordinate of the point

pY - the y coordinate of the point

pZ - the z coordinate of the point

res - will hold the result

Returns:

res

intersectSweptSphereTriangle

public static int intersectSweptSphereTriangle(float centerX,
                                               float centerY,
                                               float centerZ,
                                               float radius,
                                               float velX,
                                               float velY,
                                               float velZ,
                                               float v0X,
                                               float v0Y,
                                               float v0Z,
                                               float v1X,
                                               float v1Y,
                                               float v1Z,
                                               float v2X,
                                               float v2Y,
                                               float v2Z,
                                               float epsilon,
                                               float maxT,
                                               org.joml.Vector4f pointAndTime)

Determine the point of intersection between a sphere with the given center (centerX, centerY, centerZ) and radius moving with the given velocity (velX, velY, velZ) and the triangle specified via its three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z), (v2X, v2Y, v2Z).

The vertices of the triangle must be specified in counter-clockwise winding order.

An intersection is only considered if the time of intersection is smaller than the given maxT value.

Reference: Improved Collision detection and Response

Parameters:

centerX - the x coordinate of the sphere's center

centerY - the y coordinate of the sphere's center

centerZ - the z coordinate of the sphere's center

radius - the radius of the sphere

velX - the x component of the velocity of the sphere

velY - the y component of the velocity of the sphere

velZ - the z component of the velocity of the sphere

v0X - the x coordinate of the first triangle vertex

v0Y - the y coordinate of the first triangle vertex

v0Z - the z coordinate of the first triangle vertex

v1X - the x coordinate of the second triangle vertex

v1Y - the y coordinate of the second triangle vertex

v1Z - the z coordinate of the second triangle vertex

v2X - the x coordinate of the third triangle vertex

v2Y - the y coordinate of the third triangle vertex

v2Z - the z coordinate of the third triangle vertex

epsilon - a small epsilon when testing spheres that move almost parallel to the triangle

maxT - the maximum intersection time

pointAndTime - iff the moving sphere and the triangle intersect, this will hold the point of intersection in the (x, y, z) components and the time of intersection in the w component

Returns:

POINT_ON_TRIANGLE_FACE if the intersection point lies on the triangle's face, or POINT_ON_TRIANGLE_VERTEX_0, POINT_ON_TRIANGLE_VERTEX_1 or POINT_ON_TRIANGLE_VERTEX_2 if the intersection point is a vertex, or POINT_ON_TRIANGLE_EDGE_01, POINT_ON_TRIANGLE_EDGE_12 or POINT_ON_TRIANGLE_EDGE_20 if the intersection point lies on an edge; or 0 if no intersection

testPointInTriangle

public static boolean testPointInTriangle(float pX,
                                          float pY,
                                          float pZ,
                                          float v0X,
                                          float v0Y,
                                          float v0Z,
                                          float v1X,
                                          float v1Y,
                                          float v1Z,
                                          float v2X,
                                          float v2Y,
                                          float v2Z)

Test whether the projection of the given point (pX, pY, pZ) lies inside of the triangle defined by the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z).

Reference: Improved Collision detection and Response

Parameters:

pX - the x coordinate of the point to test

pY - the y coordinate of the point to test

pZ - the z coordinate of the point to test

v0X - the x coordinate of the first vertex

v0Y - the y coordinate of the first vertex

v0Z - the z coordinate of the first vertex

v1X - the x coordinate of the second vertex

v1Y - the y coordinate of the second vertex

v1Z - the z coordinate of the second vertex

v2X - the x coordinate of the third vertex

v2Y - the y coordinate of the third vertex

v2Z - the z coordinate of the third vertex

Returns:

true if the projection of the given point lies inside of the given triangle; false otherwise

intersectRaySphere

public static boolean intersectRaySphere(float originX,
                                         float originY,
                                         float originZ,
                                         float dirX,
                                         float dirY,
                                         float dirZ,
                                         float centerX,
                                         float centerY,
                                         float centerZ,
                                         float radiusSquared,
                                         org.joml.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.

This method returns true for a ray whose origin lies inside the sphere.

Reference: http://www.scratchapixel.com/

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

originZ - the z coordinate of the ray's origin

dirX - the x coordinate of the ray's normalized direction

dirY - the y coordinate of the ray's normalized direction

dirZ - the z coordinate of the ray's normalized direction

centerX - the x coordinate of the sphere's center

centerY - the y coordinate of the sphere's center

centerZ - the z coordinate of the sphere's center

radiusSquared - the sphere radius squared

result - a vector that will contain the values of the parameter t in the ray equation p(t) = origin + t * dir for both points (near, far) of intersections with the sphere

Returns:

true if the ray intersects the sphere; false otherwise

intersectRaySphere

public static boolean intersectRaySphere(org.joml.Vector3fc origin,
                                         org.joml.Vector3fc dir,
                                         org.joml.Vector3fc center,
                                         float radiusSquared,
                                         org.joml.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.

This method returns true for a ray whose origin lies inside the sphere.

Reference: http://www.scratchapixel.com/

Parameters:

origin - the ray's origin

dir - the ray's normalized direction

center - the sphere's center

radiusSquared - the sphere radius squared

result - a vector that will contain the values of the parameter t in the ray equation p(t) = origin + t * dir for both points (near, far) of intersections with the sphere

Returns:

true if the ray intersects the sphere; false otherwise

intersectRaySphere

public static boolean intersectRaySphere(Rayf ray,
                                         Spheref sphere,
                                         org.joml.Vector2f result)

Test whether the given ray intersects the given sphere, 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.

This method returns true for a ray whose origin lies inside the sphere.

Reference: http://www.scratchapixel.com/

Parameters:

ray - the ray

sphere - the sphere

result - a vector that will contain the values of the parameter t in the ray equation p(t) = origin + t * dir for both points (near, far) of intersections with the sphere

Returns:

true if the ray intersects the sphere; false otherwise

testRaySphere

public static boolean testRaySphere(float originX,
                                    float originY,
                                    float originZ,
                                    float dirX,
                                    float dirY,
                                    float dirZ,
                                    float centerX,
                                    float centerY,
                                    float centerZ,
                                    float radiusSquared)

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.

This method returns true for a ray whose origin lies inside the sphere.

Reference: http://www.scratchapixel.com/

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

originZ - the z coordinate of the ray's origin

dirX - the x coordinate of the ray's normalized direction

dirY - the y coordinate of the ray's normalized direction

dirZ - the z coordinate of the ray's normalized direction

centerX - the x coordinate of the sphere's center

centerY - the y coordinate of the sphere's center

centerZ - the z coordinate of the sphere's center

radiusSquared - the sphere radius squared

Returns:

true if the ray intersects the sphere; false otherwise

testRaySphere

public static boolean testRaySphere(org.joml.Vector3fc origin,
                                    org.joml.Vector3fc dir,
                                    org.joml.Vector3fc center,
                                    float radiusSquared)

Test whether the ray with the given origin and normalized direction dir intersects the sphere with the given center and square radius.

This method returns true for a ray whose origin lies inside the sphere.

Reference: http://www.scratchapixel.com/

Parameters:

origin - the ray's origin

dir - the ray's normalized direction

center - the sphere's center

radiusSquared - the sphere radius squared

Returns:

true if the ray intersects the sphere; false otherwise

testRaySphere

public static boolean testRaySphere(Rayf ray,
                                    Spheref sphere)

Test whether the given ray intersects the given sphere.

This method returns true for a ray whose origin lies inside the sphere.

Reference: http://www.scratchapixel.com/

Parameters:

ray - the ray

sphere - the sphere

Returns:

true if the ray intersects the sphere; false otherwise

testLineSegmentSphere

public static boolean testLineSegmentSphere(float p0X,
                                            float p0Y,
                                            float p0Z,
                                            float p1X,
                                            float p1Y,
                                            float p1Z,
                                            float centerX,
                                            float centerY,
                                            float centerZ,
                                            float radiusSquared)

Test whether the line segment with the end points (p0X, p0Y, p0Z) and (p1X, p1Y, p1Z) intersects the given sphere with center (centerX, centerY, centerZ) and square radius radiusSquared.

Reference: http://paulbourke.net/

Parameters:

p0X - the x coordinate of the line segment's first end point

p0Y - the y coordinate of the line segment's first end point

p0Z - the z coordinate of the line segment's first end point

p1X - the x coordinate of the line segment's second end point

p1Y - the y coordinate of the line segment's second end point

p1Z - the z coordinate of the line segment's second end point

centerX - the x coordinate of the sphere's center

centerY - the y coordinate of the sphere's center

centerZ - the z coordinate of the sphere's center

radiusSquared - the sphere radius squared

Returns:

true if the line segment intersects the sphere; false otherwise

testLineSegmentSphere

public static boolean testLineSegmentSphere(org.joml.Vector3fc p0,
                                            org.joml.Vector3fc p1,
                                            org.joml.Vector3fc center,
                                            float radiusSquared)

Test whether the line segment with the end points p0 and p1 intersects the given sphere with center center and square radius radiusSquared.

Reference: http://paulbourke.net/

Parameters:

p0 - the line segment's first end point

p1 - the line segment's second end point

center - the sphere's center

radiusSquared - the sphere radius squared

Returns:

true if the line segment intersects the sphere; false otherwise

intersectRayAab

public static boolean 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,
                                      org.joml.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.

This method returns true for a ray whose origin lies inside the axis-aligned box.

If many boxes need to be tested against the same ray, then the RayAabIntersection class is likely more efficient.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

originZ - the z coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

dirZ - the z coordinate of the ray's direction

minX - the x coordinate of the minimum corner of the axis-aligned box

minY - the y coordinate of the minimum corner of the axis-aligned box

minZ - the z coordinate of the minimum corner of the axis-aligned box

maxX - the x coordinate of the maximum corner of the axis-aligned box

maxY - the y coordinate of the maximum corner of the axis-aligned box

maxZ - the y coordinate of the maximum corner of the axis-aligned box

result - a vector which will hold the resulting values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection iff the ray intersects the axis-aligned box

Returns:

true if the given ray intersects the axis-aligned box; false otherwise

See Also:

intersectRayAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f), RayAabIntersection

intersectRayAab

public static boolean intersectRayAab(org.joml.Vector3fc origin,
                                      org.joml.Vector3fc dir,
                                      org.joml.Vector3fc min,
                                      org.joml.Vector3fc max,
                                      org.joml.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..

This method returns true for a ray whose origin lies inside the axis-aligned box.

If many boxes need to be tested against the same ray, then the RayAabIntersection class is likely more efficient.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

origin - the ray's origin

dir - the ray's direction

min - the minimum corner of the axis-aligned box

max - the maximum corner of the axis-aligned box

result - a vector which will hold the resulting values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection iff the ray intersects the axis-aligned box

Returns:

true if the given ray intersects the axis-aligned box; false otherwise

See Also:

intersectRayAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f), RayAabIntersection

intersectRayAab

public static boolean intersectRayAab(Rayf ray,
                                      AABBf aabb,
                                      org.joml.Vector2f result)

Test whether the given ray intersects given the axis-aligned box 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..

This method returns true for a ray whose origin lies inside the axis-aligned box.

If many boxes need to be tested against the same ray, then the RayAabIntersection class is likely more efficient.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

ray - the ray

aabb - the AABB

result - a vector which will hold the resulting values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection iff the ray intersects the axis-aligned box

Returns:

true if the given ray intersects the axis-aligned box; false otherwise

See Also:

intersectRayAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f), RayAabIntersection

intersectRayAab

public static boolean intersectRayAab(Rayf ray,
                                      AABBi aabb,
                                      org.joml.Vector2f result)

Test whether the given ray intersects given the axis-aligned box 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..

This method returns true for a ray whose origin lies inside the axis-aligned box.

If many boxes need to be tested against the same ray, then the RayAabIntersection class is likely more efficient.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

ray - the ray

aabb - the AABB

result - a vector which will hold the resulting values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection iff the ray intersects the axis-aligned box

Returns:

true if the given ray intersects the axis-aligned box; false otherwise

See Also:

intersectRayAab(float, float, float, float, float, float, float, float, float, float, float, float, Vector2f), RayAabIntersection

intersectLineSegmentAab

public static int 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,
                                          org.joml.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.

This method returns true for a line segment whose either end point lies inside the axis-aligned box.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

p0X - the x coordinate of the line segment's first end point

p0Y - the y coordinate of the line segment's first end point

p0Z - the z coordinate of the line segment's first end point

p1X - the x coordinate of the line segment's second end point

p1Y - the y coordinate of the line segment's second end point

p1Z - the z coordinate of the line segment's second end point

minX - the x coordinate of one corner of the axis-aligned box

minY - the y coordinate of one corner of the axis-aligned box

minZ - the z coordinate of one corner of the axis-aligned box

maxX - the x coordinate of the opposite corner of the axis-aligned box

maxY - the y coordinate of the opposite corner of the axis-aligned box

maxZ - the y coordinate of the opposite corner of the axis-aligned box

result - a vector which will hold the resulting values of the parameter t in the ray equation p(t) = p0 + t * (p1 - p0) of the near and far point of intersection iff the line segment intersects the axis-aligned box

Returns:

INSIDE if the line segment lies completely inside of the axis-aligned box; or OUTSIDE if the line segment lies completely outside of the axis-aligned box; or ONE_INTERSECTION if one of the end points of the line segment lies inside of the axis-aligned box; or TWO_INTERSECTION if the line segment intersects two sides of the axis-aligned box or lies on an edge or a side of the box

See Also:

intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f)

intersectLineSegmentAab

public static int intersectLineSegmentAab(org.joml.Vector3fc p0,
                                          org.joml.Vector3fc p1,
                                          org.joml.Vector3fc min,
                                          org.joml.Vector3fc max,
                                          org.joml.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.

This method returns true for a line segment whose either end point lies inside the axis-aligned box.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

p0 - the line segment's first end point

p1 - the line segment's second end point

min - the minimum corner of the axis-aligned box

max - the maximum corner of the axis-aligned box

result - a vector which will hold the resulting values of the parameter t in the ray equation p(t) = p0 + t * (p1 - p0) of the near and far point of intersection iff the line segment intersects the axis-aligned box

Returns:

INSIDE if the line segment lies completely inside of the axis-aligned box; or OUTSIDE if the line segment lies completely outside of the axis-aligned box; or ONE_INTERSECTION if one of the end points of the line segment lies inside of the axis-aligned box; or TWO_INTERSECTION if the line segment intersects two sides of the axis-aligned box or lies on an edge or a side of the box

See Also:

intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f)

intersectLineSegmentAab

public static int intersectLineSegmentAab(LineSegmentf lineSegment,
                                          AABBf aabb,
                                          org.joml.Vector2f result)

Determine whether the given undirected line segment intersects the given axis-aligned box, 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.

This method returns true for a line segment whose either end point lies inside the axis-aligned box.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

lineSegment - the line segment

aabb - the AABB

result - a vector which will hold the resulting values of the parameter t in the ray equation p(t) = p0 + t * (p1 - p0) of the near and far point of intersection iff the line segment intersects the axis-aligned box

Returns:

INSIDE if the line segment lies completely inside of the axis-aligned box; or OUTSIDE if the line segment lies completely outside of the axis-aligned box; or ONE_INTERSECTION if one of the end points of the line segment lies inside of the axis-aligned box; or TWO_INTERSECTION if the line segment intersects two sides of the axis-aligned box or lies on an edge or a side of the box

See Also:

intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f)

intersectLineSegmentAab

public static int intersectLineSegmentAab(LineSegmentf lineSegment,
                                          AABBi aabb,
                                          org.joml.Vector2f result)

Determine whether the given undirected line segment intersects the given axis-aligned box, 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.

This method returns true for a line segment whose either end point lies inside the axis-aligned box.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

lineSegment - the line segment

aabb - the AABB

result - a vector which will hold the resulting values of the parameter t in the ray equation p(t) = p0 + t * (p1 - p0) of the near and far point of intersection iff the line segment intersects the axis-aligned box

Returns:

INSIDE if the line segment lies completely inside of the axis-aligned box; or OUTSIDE if the line segment lies completely outside of the axis-aligned box; or ONE_INTERSECTION if one of the end points of the line segment lies inside of the axis-aligned box; or TWO_INTERSECTION if the line segment intersects two sides of the axis-aligned box or lies on an edge or a side of the box

See Also:

intersectLineSegmentAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector2f)

testRayAab

public static boolean testRayAab(float originX,
                                 float originY,
                                 float originZ,
                                 float dirX,
                                 float dirY,
                                 float dirZ,
                                 float minX,
                                 float minY,
                                 float minZ,
                                 float maxX,
                                 float maxY,
                                 float maxZ)

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

This method returns true for a ray whose origin lies inside the axis-aligned box.

If many boxes need to be tested against the same ray, then the RayAabIntersection class is likely more efficient.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

originZ - the z coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

dirZ - the z coordinate of the ray's direction

minX - the x coordinate of the minimum corner of the axis-aligned box

minY - the y coordinate of the minimum corner of the axis-aligned box

minZ - the z coordinate of the minimum corner of the axis-aligned box

maxX - the x coordinate of the maximum corner of the axis-aligned box

maxY - the y coordinate of the maximum corner of the axis-aligned box

maxZ - the y coordinate of the maximum corner of the axis-aligned box

Returns:

true if the given ray intersects the axis-aligned box; false otherwise

See Also:

testRayAab(Vector3fc, Vector3fc, Vector3fc, Vector3fc), RayAabIntersection

testRayAab

public static boolean testRayAab(org.joml.Vector3fc origin,
                                 org.joml.Vector3fc dir,
                                 org.joml.Vector3fc min,
                                 org.joml.Vector3fc max)

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.

This method returns true for a ray whose origin lies inside the axis-aligned box.

If many boxes need to be tested against the same ray, then the RayAabIntersection class is likely more efficient.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

origin - the ray's origin

dir - the ray's direction

min - the minimum corner of the axis-aligned box

max - the maximum corner of the axis-aligned box

Returns:

true if the given ray intersects the axis-aligned box; false otherwise

See Also:

testRayAab(float, float, float, float, float, float, float, float, float, float, float, float), RayAabIntersection

testRayAab

public static boolean testRayAab(Rayf ray,
                                 AABBf aabb)

Test whether the given ray intersects the given axis-aligned box.

This method returns true for a ray whose origin lies inside the axis-aligned box.

If many boxes need to be tested against the same ray, then the RayAabIntersection class is likely more efficient.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

ray - the ray

aabb - the AABB

Returns:

true if the given ray intersects the axis-aligned box; false otherwise

See Also:

testRayAab(float, float, float, float, float, float, float, float, float, float, float, float), RayAabIntersection

testRayAab

public static boolean testRayAab(Rayf ray,
                                 AABBi aabb)

Test whether the given ray intersects the given axis-aligned box.

This method returns true for a ray whose origin lies inside the axis-aligned box.

If many boxes need to be tested against the same ray, then the RayAabIntersection class is likely more efficient.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

ray - the ray

aabb - the AABB

Returns:

true if the given ray intersects the axis-aligned box; false otherwise

See Also:

testRayAab(float, float, float, float, float, float, float, float, float, float, float, float), RayAabIntersection

testRayTriangleFront

public static boolean testRayTriangleFront(float originX,
                                           float originY,
                                           float originZ,
                                           float dirX,
                                           float dirY,
                                           float dirZ,
                                           float v0X,
                                           float v0Y,
                                           float v0Z,
                                           float v1X,
                                           float v1Y,
                                           float v1Z,
                                           float v2X,
                                           float v2Y,
                                           float v2Z,
                                           float epsilon)

Test whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the frontface of the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z).

This is an implementation of the Fast, Minimum Storage Ray/Triangle Intersection method.

This test implements backface culling, that is, it will return false when the triangle is in clockwise winding order assuming a right-handed coordinate system when seen along the ray's direction, even if the ray intersects the triangle. This is in compliance with how OpenGL handles backface culling with default frontface/backface settings.

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

originZ - the z coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

dirZ - the z coordinate of the ray's direction

v0X - the x coordinate of the first vertex

v0Y - the y coordinate of the first vertex

v0Z - the z coordinate of the first vertex

v1X - the x coordinate of the second vertex

v1Y - the y coordinate of the second vertex

v1Z - the z coordinate of the second vertex

v2X - the x coordinate of the third vertex

v2Y - the y coordinate of the third vertex

v2Z - the z coordinate of the third vertex

epsilon - a small epsilon when testing rays that are almost parallel to the triangle

Returns:

true if the given ray intersects the frontface of the triangle; false otherwise

See Also:

testRayTriangleFront(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3fc, float)

testRayTriangleFront

public static boolean testRayTriangleFront(org.joml.Vector3fc origin,
                                           org.joml.Vector3fc dir,
                                           org.joml.Vector3fc v0,
                                           org.joml.Vector3fc v1,
                                           org.joml.Vector3fc v2,
                                           float epsilon)

Test whether the ray with the given origin and the given dir intersects the frontface of the triangle consisting of the three vertices v0, v1 and v2.

This is an implementation of the Fast, Minimum Storage Ray/Triangle Intersection method.

This test implements backface culling, that is, it will return false when the triangle is in clockwise winding order assuming a right-handed coordinate system when seen along the ray's direction, even if the ray intersects the triangle. This is in compliance with how OpenGL handles backface culling with default frontface/backface settings.

Parameters:

origin - the ray's origin

dir - the ray's direction

v0 - the position of the first vertex

v1 - the position of the second vertex

v2 - the position of the third vertex

epsilon - a small epsilon when testing rays that are almost parallel to the triangle

Returns:

true if the given ray intersects the frontface of the triangle; false otherwise

See Also:

testRayTriangleFront(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)

testRayTriangle

public static boolean testRayTriangle(float originX,
                                      float originY,
                                      float originZ,
                                      float dirX,
                                      float dirY,
                                      float dirZ,
                                      float v0X,
                                      float v0Y,
                                      float v0Z,
                                      float v1X,
                                      float v1Y,
                                      float v1Z,
                                      float v2X,
                                      float v2Y,
                                      float v2Z,
                                      float epsilon)

Test whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z).

This is an implementation of the Fast, Minimum Storage Ray/Triangle Intersection method.

This test does not take into account the winding order of the triangle, so a ray will intersect a front-facing triangle as well as a back-facing triangle.

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

originZ - the z coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

dirZ - the z coordinate of the ray's direction

v0X - the x coordinate of the first vertex

v0Y - the y coordinate of the first vertex

v0Z - the z coordinate of the first vertex

v1X - the x coordinate of the second vertex

v1Y - the y coordinate of the second vertex

v1Z - the z coordinate of the second vertex

v2X - the x coordinate of the third vertex

v2Y - the y coordinate of the third vertex

v2Z - the z coordinate of the third vertex

epsilon - a small epsilon when testing rays that are almost parallel to the triangle

Returns:

true if the given ray intersects the frontface of the triangle; false otherwise

See Also:

testRayTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3fc, float)

testRayTriangle

public static boolean testRayTriangle(org.joml.Vector3fc origin,
                                      org.joml.Vector3fc dir,
                                      org.joml.Vector3fc v0,
                                      org.joml.Vector3fc v1,
                                      org.joml.Vector3fc v2,
                                      float epsilon)

Test whether the ray with the given origin and the given dir intersects the frontface of the triangle consisting of the three vertices v0, v1 and v2.

This is an implementation of the Fast, Minimum Storage Ray/Triangle Intersection method.

This test does not take into account the winding order of the triangle, so a ray will intersect a front-facing triangle as well as a back-facing triangle.

Parameters:

origin - the ray's origin

dir - the ray's direction

v0 - the position of the first vertex

v1 - the position of the second vertex

v2 - the position of the third vertex

epsilon - a small epsilon when testing rays that are almost parallel to the triangle

Returns:

true if the given ray intersects the frontface of the triangle; false otherwise

See Also:

testRayTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)

intersectRayTriangleFront

public static float intersectRayTriangleFront(float originX,
                                              float originY,
                                              float originZ,
                                              float dirX,
                                              float dirY,
                                              float dirZ,
                                              float v0X,
                                              float v0Y,
                                              float v0Z,
                                              float v1X,
                                              float v1Y,
                                              float v1Z,
                                              float v2X,
                                              float v2Y,
                                              float v2Z,
                                              float epsilon)

Determine whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the frontface of the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z) and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection.

This is an implementation of the Fast, Minimum Storage Ray/Triangle Intersection method.

This test implements backface culling, that is, it will return false when the triangle is in clockwise winding order assuming a right-handed coordinate system when seen along the ray's direction, even if the ray intersects the triangle. This is in compliance with how OpenGL handles backface culling with default frontface/backface settings.

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

originZ - the z coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

dirZ - the z coordinate of the ray's direction

v0X - the x coordinate of the first vertex

v0Y - the y coordinate of the first vertex

v0Z - the z coordinate of the first vertex

v1X - the x coordinate of the second vertex

v1Y - the y coordinate of the second vertex

v1Z - the z coordinate of the second vertex

v2X - the x coordinate of the third vertex

v2Y - the y coordinate of the third vertex

v2Z - the z coordinate of the third vertex

epsilon - a small epsilon when testing rays that are almost parallel to the triangle

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection if the ray intersects the frontface of the triangle; -1.0 otherwise

See Also:

testRayTriangleFront(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3fc, float)

intersectRayTriangleFront

public static float intersectRayTriangleFront(org.joml.Vector3fc origin,
                                              org.joml.Vector3fc dir,
                                              org.joml.Vector3fc v0,
                                              org.joml.Vector3fc v1,
                                              org.joml.Vector3fc v2,
                                              float epsilon)

Determine whether the ray with the given origin and the given dir intersects the frontface of the triangle consisting of the three vertices v0, v1 and v2 and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection.

This is an implementation of the Fast, Minimum Storage Ray/Triangle Intersection method.

This test implements backface culling, that is, it will return false when the triangle is in clockwise winding order assuming a right-handed coordinate system when seen along the ray's direction, even if the ray intersects the triangle. This is in compliance with how OpenGL handles backface culling with default frontface/backface settings.

Parameters:

origin - the ray's origin

dir - the ray's direction

v0 - the position of the first vertex

v1 - the position of the second vertex

v2 - the position of the third vertex

epsilon - a small epsilon when testing rays that are almost parallel to the triangle

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection if the ray intersects the frontface of the triangle; -1.0 otherwise

See Also:

intersectRayTriangleFront(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)

intersectRayTriangle

public static float intersectRayTriangle(float originX,
                                         float originY,
                                         float originZ,
                                         float dirX,
                                         float dirY,
                                         float dirZ,
                                         float v0X,
                                         float v0Y,
                                         float v0Z,
                                         float v1X,
                                         float v1Y,
                                         float v1Z,
                                         float v2X,
                                         float v2Y,
                                         float v2Z,
                                         float epsilon)

Determine whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ) intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z) and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection.

This is an implementation of the Fast, Minimum Storage Ray/Triangle Intersection method.

This test does not take into account the winding order of the triangle, so a ray will intersect a front-facing triangle as well as a back-facing triangle.

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

originZ - the z coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

dirZ - the z coordinate of the ray's direction

v0X - the x coordinate of the first vertex

v0Y - the y coordinate of the first vertex

v0Z - the z coordinate of the first vertex

v1X - the x coordinate of the second vertex

v1Y - the y coordinate of the second vertex

v1Z - the z coordinate of the second vertex

v2X - the x coordinate of the third vertex

v2Y - the y coordinate of the third vertex

v2Z - the z coordinate of the third vertex

epsilon - a small epsilon when testing rays that are almost parallel to the triangle

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection if the ray intersects the triangle; -1.0 otherwise

See Also:

testRayTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3fc, float)

intersectRayTriangle

public static float intersectRayTriangle(org.joml.Vector3fc origin,
                                         org.joml.Vector3fc dir,
                                         org.joml.Vector3fc v0,
                                         org.joml.Vector3fc v1,
                                         org.joml.Vector3fc v2,
                                         float epsilon)

Determine whether the ray with the given origin and the given dir intersects the triangle consisting of the three vertices v0, v1 and v2 and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection.

This is an implementation of the Fast, Minimum Storage Ray/Triangle Intersection method.

This test does not take into account the winding order of the triangle, so a ray will intersect a front-facing triangle as well as a back-facing triangle.

Parameters:

origin - the ray's origin

dir - the ray's direction

v0 - the position of the first vertex

v1 - the position of the second vertex

v2 - the position of the third vertex

epsilon - a small epsilon when testing rays that are almost parallel to the triangle

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection if the ray intersects the triangle; -1.0 otherwise

See Also:

intersectRayTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)

testLineSegmentTriangle

public static boolean testLineSegmentTriangle(float p0X,
                                              float p0Y,
                                              float p0Z,
                                              float p1X,
                                              float p1Y,
                                              float p1Z,
                                              float v0X,
                                              float v0Y,
                                              float v0Z,
                                              float v1X,
                                              float v1Y,
                                              float v1Z,
                                              float v2X,
                                              float v2Y,
                                              float v2Z,
                                              float epsilon)

Test whether the line segment with the end points (p0X, p0Y, p0Z) and (p1X, p1Y, p1Z) intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z), regardless of the winding order of the triangle or the direction of the line segment between its two end points.

Reference: Fast, Minimum Storage Ray/Triangle Intersection

Parameters:

p0X - the x coordinate of the line segment's first end point

p0Y - the y coordinate of the line segment's first end point

p0Z - the z coordinate of the line segment's first end point

p1X - the x coordinate of the line segment's second end point

p1Y - the y coordinate of the line segment's second end point

p1Z - the z coordinate of the line segment's second end point

v0X - the x coordinate of the first vertex

v0Y - the y coordinate of the first vertex

v0Z - the z coordinate of the first vertex

v1X - the x coordinate of the second vertex

v1Y - the y coordinate of the second vertex

v1Z - the z coordinate of the second vertex

v2X - the x coordinate of the third vertex

v2Y - the y coordinate of the third vertex

v2Z - the z coordinate of the third vertex

epsilon - a small epsilon when testing line segments that are almost parallel to the triangle

Returns:

true if the given line segment intersects the triangle; false otherwise

See Also:

testLineSegmentTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3fc, float)

testLineSegmentTriangle

public static boolean testLineSegmentTriangle(org.joml.Vector3fc p0,
                                              org.joml.Vector3fc p1,
                                              org.joml.Vector3fc v0,
                                              org.joml.Vector3fc v1,
                                              org.joml.Vector3fc v2,
                                              float epsilon)

Test whether the line segment with the end points p0 and p1 intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z), regardless of the winding order of the triangle or the direction of the line segment between its two end points.

Reference: Fast, Minimum Storage Ray/Triangle Intersection

Parameters:

p0 - the line segment's first end point

p1 - the line segment's second end point

v0 - the position of the first vertex

v1 - the position of the second vertex

v2 - the position of the third vertex

epsilon - a small epsilon when testing line segments that are almost parallel to the triangle

Returns:

true if the given line segment intersects the triangle; false otherwise

See Also:

testLineSegmentTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)

intersectLineSegmentTriangle

public static boolean intersectLineSegmentTriangle(float p0X,
                                                   float p0Y,
                                                   float p0Z,
                                                   float p1X,
                                                   float p1Y,
                                                   float p1Z,
                                                   float v0X,
                                                   float v0Y,
                                                   float v0Z,
                                                   float v1X,
                                                   float v1Y,
                                                   float v1Z,
                                                   float v2X,
                                                   float v2Y,
                                                   float v2Z,
                                                   float epsilon,
                                                   org.joml.Vector3f intersectionPoint)

Determine whether the line segment with the end points (p0X, p0Y, p0Z) and (p1X, p1Y, p1Z) intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z), regardless of the winding order of the triangle or the direction of the line segment between its two end points, and return the point of intersection.

Reference: Fast, Minimum Storage Ray/Triangle Intersection

Parameters:

p0X - the x coordinate of the line segment's first end point

p0Y - the y coordinate of the line segment's first end point

p0Z - the z coordinate of the line segment's first end point

p1X - the x coordinate of the line segment's second end point

p1Y - the y coordinate of the line segment's second end point

p1Z - the z coordinate of the line segment's second end point

v0X - the x coordinate of the first vertex

v0Y - the y coordinate of the first vertex

v0Z - the z coordinate of the first vertex

v1X - the x coordinate of the second vertex

v1Y - the y coordinate of the second vertex

v1Z - the z coordinate of the second vertex

v2X - the x coordinate of the third vertex

v2Y - the y coordinate of the third vertex

v2Z - the z coordinate of the third vertex

epsilon - a small epsilon when testing line segments that are almost parallel to the triangle

intersectionPoint - the point of intersection

Returns:

true if the given line segment intersects the triangle; false otherwise

See Also:

intersectLineSegmentTriangle(Vector3fc, Vector3fc, Vector3fc, Vector3fc, Vector3fc, float, Vector3f)

intersectLineSegmentTriangle

public static boolean intersectLineSegmentTriangle(org.joml.Vector3fc p0,
                                                   org.joml.Vector3fc p1,
                                                   org.joml.Vector3fc v0,
                                                   org.joml.Vector3fc v1,
                                                   org.joml.Vector3fc v2,
                                                   float epsilon,
                                                   org.joml.Vector3f intersectionPoint)

Determine whether the line segment with the end points p0 and p1 intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z), regardless of the winding order of the triangle or the direction of the line segment between its two end points, and return the point of intersection.

Reference: Fast, Minimum Storage Ray/Triangle Intersection

Parameters:

p0 - the line segment's first end point

p1 - the line segment's second end point

v0 - the position of the first vertex

v1 - the position of the second vertex

v2 - the position of the third vertex

epsilon - a small epsilon when testing line segments that are almost parallel to the triangle

intersectionPoint - the point of intersection

Returns:

true if the given line segment intersects the triangle; false otherwise

See Also:

intersectLineSegmentTriangle(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, Vector3f)

intersectLineSegmentPlane

public static boolean intersectLineSegmentPlane(float p0X,
                                                float p0Y,
                                                float p0Z,
                                                float p1X,
                                                float p1Y,
                                                float p1Z,
                                                float a,
                                                float b,
                                                float c,
                                                float d,
                                                org.joml.Vector3f intersectionPoint)

Determine whether the line segment with the end points (p0X, p0Y, p0Z) and (p1X, p1Y, p1Z) intersects the plane given as the general plane equation a*x + b*y + c*z + d = 0, and return the point of intersection.

Parameters:

p0X - the x coordinate of the line segment's first end point

p0Y - the y coordinate of the line segment's first end point

p0Z - the z coordinate of the line segment's first end point

p1X - the x coordinate of the line segment's second end point

p1Y - the y coordinate of the line segment's second end point

p1Z - the z coordinate of the line segment's second end point

a - the x factor in the plane equation

b - the y factor in the plane equation

c - the z factor in the plane equation

d - the constant in the plane equation

intersectionPoint - the point of intersection

Returns:

true if the given line segment intersects the plane; false otherwise

testLineCircle

public static boolean testLineCircle(float a,
                                     float b,
                                     float c,
                                     float centerX,
                                     float centerY,
                                     float radius)

Test whether the line with the general line equation a*x + b*y + c = 0 intersects the circle with center (centerX, centerY) and radius.

Reference: http://math.stackexchange.com

Parameters:

a - the x factor in the line equation

b - the y factor in the line equation

c - the constant in the line equation

centerX - the x coordinate of the circle's center

centerY - the y coordinate of the circle's center

radius - the radius of the circle

Returns:

true iff the line intersects the circle; false otherwise

intersectLineCircle

public static boolean intersectLineCircle(float a,
                                          float b,
                                          float c,
                                          float centerX,
                                          float centerY,
                                          float radius,
                                          org.joml.Vector3f intersectionCenterAndHL)

Test whether the line with the general line equation a*x + b*y + c = 0 intersects the circle with center (centerX, centerY) and radius, 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.

Reference: http://math.stackexchange.com

Parameters:

a - the x factor in the line equation

b - the y factor in the line equation

c - the constant in the line equation

centerX - the x coordinate of the circle's center

centerY - the y coordinate of the circle's center

radius - the radius of the circle

intersectionCenterAndHL - will hold the center of the line segment of intersection in the (x, y) components and the half-length in the z component

Returns:

true iff the line intersects the circle; false otherwise

intersectLineCircle

public static boolean intersectLineCircle(float x0,
                                          float y0,
                                          float x1,
                                          float y1,
                                          float centerX,
                                          float centerY,
                                          float radius,
                                          org.joml.Vector3f intersectionCenterAndHL)

Test whether the line defined by the two points (x0, y0) and (x1, y1) intersects the circle with center (centerX, centerY) and radius, 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.

Reference: http://math.stackexchange.com

Parameters:

x0 - the x coordinate of the first point on the line

y0 - the y coordinate of the first point on the line

x1 - the x coordinate of the second point on the line

y1 - the y coordinate of the second point on the line

centerX - the x coordinate of the circle's center

centerY - the y coordinate of the circle's center

radius - the radius of the circle

intersectionCenterAndHL - will hold the center of the line segment of intersection in the (x, y) components and the half-length in the z component

Returns:

true iff the line intersects the circle; false otherwise

testAarLine

public static boolean testAarLine(float minX,
                                  float minY,
                                  float maxX,
                                  float maxY,
                                  float a,
                                  float b,
                                  float c)

Test whether the axis-aligned rectangle with minimum corner (minX, minY) and maximum corner (maxX, maxY) intersects the line with the general equation a*x + b*y + c = 0.

Reference: http://www.lighthouse3d.com ("Geometric Approach - Testing Boxes II")

Parameters:

minX - the x coordinate of the minimum corner of the axis-aligned rectangle

minY - the y coordinate of the minimum corner of the axis-aligned rectangle

maxX - the x coordinate of the maximum corner of the axis-aligned rectangle

maxY - the y coordinate of the maximum corner of the axis-aligned rectangle

a - the x factor in the line equation

b - the y factor in the line equation

c - the constant in the plane equation

Returns:

true iff the axis-aligned rectangle intersects the line; false otherwise

testAarLine

public static boolean testAarLine(org.joml.Vector2fc min,
                                  org.joml.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.

Reference: http://www.lighthouse3d.com ("Geometric Approach - Testing Boxes II")

Parameters:

min - the minimum corner of the axis-aligned rectangle

max - the maximum corner of the axis-aligned rectangle

a - the x factor in the line equation

b - the y factor in the line equation

c - the constant in the line equation

Returns:

true iff the axis-aligned rectangle intersects the line; false otherwise

testAarLine

public static boolean testAarLine(float minX,
                                  float minY,
                                  float maxX,
                                  float maxY,
                                  float x0,
                                  float y0,
                                  float x1,
                                  float y1)

Test whether the axis-aligned rectangle with minimum corner (minX, minY) and maximum corner (maxX, maxY) intersects the line defined by the two points (x0, y0) and (x1, y1).

Reference: http://www.lighthouse3d.com ("Geometric Approach - Testing Boxes II")

Parameters:

minX - the x coordinate of the minimum corner of the axis-aligned rectangle

minY - the y coordinate of the minimum corner of the axis-aligned rectangle

maxX - the x coordinate of the maximum corner of the axis-aligned rectangle

maxY - the y coordinate of the maximum corner of the axis-aligned rectangle

x0 - the x coordinate of the first point on the line

y0 - the y coordinate of the first point on the line

x1 - the x coordinate of the second point on the line

y1 - the y coordinate of the second point on the line

Returns:

true iff the axis-aligned rectangle intersects the line; false otherwise

testAarAar

public static boolean testAarAar(float minXA,
                                 float minYA,
                                 float maxXA,
                                 float maxYA,
                                 float minXB,
                                 float minYB,
                                 float maxXB,
                                 float maxYB)

Test whether the axis-aligned rectangle with minimum corner (minXA, minYA) and maximum corner (maxXA, maxYA) intersects the axis-aligned rectangle with minimum corner (minXB, minYB) and maximum corner (maxXB, maxYB).

Parameters:

minXA - the x coordinate of the minimum corner of the first axis-aligned rectangle

minYA - the y coordinate of the minimum corner of the first axis-aligned rectangle

maxXA - the x coordinate of the maximum corner of the first axis-aligned rectangle

maxYA - the y coordinate of the maximum corner of the first axis-aligned rectangle

minXB - the x coordinate of the minimum corner of the second axis-aligned rectangle

minYB - the y coordinate of the minimum corner of the second axis-aligned rectangle

maxXB - the x coordinate of the maximum corner of the second axis-aligned rectangle

maxYB - the y coordinate of the maximum corner of the second axis-aligned rectangle

Returns:

true iff both axis-aligned rectangles intersect; false otherwise

testAarAar

public static boolean testAarAar(org.joml.Vector2fc minA,
                                 org.joml.Vector2fc maxA,
                                 org.joml.Vector2fc minB,
                                 org.joml.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.

Parameters:

minA - the minimum corner of the first axis-aligned rectangle

maxA - the maximum corner of the first axis-aligned rectangle

minB - the minimum corner of the second axis-aligned rectangle

maxB - the maximum corner of the second axis-aligned rectangle

Returns:

true iff both axis-aligned rectangles intersect; false otherwise

testMovingCircleCircle

public static boolean testMovingCircleCircle(float aX,
                                             float aY,
                                             float maX,
                                             float maY,
                                             float aR,
                                             float bX,
                                             float bY,
                                             float bR)

Test whether a given circle with center (aX, aY) and radius aR and travelled distance vector (maX, maY) intersects a given static circle with center (bX, bY) and radius bR.

Note that the case of two moving circles can always be reduced to this case by expressing the moved distance of one of the circles relative to the other.

Reference: https://www.gamasutra.com

Parameters:

aX - the x coordinate of the first circle's center

aY - the y coordinate of the first circle's center

maX - the x coordinate of the first circle's travelled distance vector

maY - the y coordinate of the first circle's travelled distance vector

aR - the radius of the first circle

bX - the x coordinate of the second circle's center

bY - the y coordinate of the second circle's center

bR - the radius of the second circle

Returns:

true if both circle intersect; false otherwise

testMovingCircleCircle

public static boolean testMovingCircleCircle(org.joml.Vector2f centerA,
                                             org.joml.Vector2f moveA,
                                             float aR,
                                             org.joml.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.

Note that the case of two moving circles can always be reduced to this case by expressing the moved distance of one of the circles relative to the other.

Reference: https://www.gamasutra.com

Parameters:

centerA - the coordinates of the first circle's center

moveA - the coordinates of the first circle's travelled distance vector

aR - the radius of the first circle

centerB - the coordinates of the second circle's center

bR - the radius of the second circle

Returns:

true if both circle intersect; false otherwise

intersectCircleCircle

public static boolean intersectCircleCircle(float aX,
                                            float aY,
                                            float radiusSquaredA,
                                            float bX,
                                            float bY,
                                            float radiusSquaredB,
                                            org.joml.Vector3f intersectionCenterAndHL)

Test whether the one circle with center (aX, aY) and square radius radiusSquaredA intersects the other circle with center (bX, bY) 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.

This method returns false when one circle contains the other circle.

Reference: http://gamedev.stackexchange.com

Parameters:

aX - the x coordinate of the first circle's center

aY - the y coordinate of the first circle's center

radiusSquaredA - the square of the first circle's radius

bX - the x coordinate of the second circle's center

bY - the y coordinate of the second circle's center

radiusSquaredB - the square of the second circle's radius

intersectionCenterAndHL - will hold the center of the circle of intersection in the (x, y, z) components and the radius in the w component

Returns:

true iff both circles intersect; false otherwise

intersectCircleCircle

public static boolean intersectCircleCircle(org.joml.Vector2fc centerA,
                                            float radiusSquaredA,
                                            org.joml.Vector2fc centerB,
                                            float radiusSquaredB,
                                            org.joml.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.

This method returns false when one circle contains the other circle.

Reference: http://gamedev.stackexchange.com

Parameters:

centerA - the first circle's center

radiusSquaredA - the square of the first circle's radius

centerB - the second circle's center

radiusSquaredB - the square of the second circle's radius

intersectionCenterAndHL - will hold the center of the line segment of intersection in the (x, y) components and the half-length in the z component

Returns:

true iff both circles intersect; false otherwise

testCircleCircle

public static boolean testCircleCircle(float aX,
                                       float aY,
                                       float rA,
                                       float bX,
                                       float bY,
                                       float rB)

Test whether the one circle with center (aX, aY) and radius rA intersects the other circle with center (bX, bY) and radius rB.

This method returns true when one circle contains the other circle.

Reference: http://math.stackexchange.com/

Parameters:

aX - the x coordinate of the first circle's center

aY - the y coordinate of the first circle's center

rA - the square of the first circle's radius

bX - the x coordinate of the second circle's center

bY - the y coordinate of the second circle's center

rB - the square of the second circle's radius

Returns:

true iff both circles intersect; false otherwise

testCircleCircle

public static boolean testCircleCircle(org.joml.Vector2fc centerA,
                                       float radiusSquaredA,
                                       org.joml.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.

This method returns true when one circle contains the other circle.

Reference: http://gamedev.stackexchange.com

Parameters:

centerA - the first circle's center

radiusSquaredA - the square of the first circle's radius

centerB - the second circle's center

radiusSquaredB - the square of the second circle's radius

Returns:

true iff both circles intersect; false otherwise

distancePointLine

public static float distancePointLine(float pointX,
                                      float pointY,
                                      float a,
                                      float b,
                                      float c)

Determine the signed distance of the given point (pointX, pointY) to the line specified via its general plane equation a*x + b*y + c = 0.

Reference: http://mathworld.wolfram.com

Parameters:

pointX - the x coordinate of the point

pointY - the y coordinate of the point

a - the x factor in the plane equation

b - the y factor in the plane equation

c - the constant in the plane equation

Returns:

the distance between the point and the line

distancePointLine

public static float distancePointLine(float pointX,
                                      float pointY,
                                      float x0,
                                      float y0,
                                      float x1,
                                      float y1)

Determine the signed distance of the given point (pointX, pointY) to the line defined by the two points (x0, y0) and (x1, y1).

Reference: http://mathworld.wolfram.com

Parameters:

pointX - the x coordinate of the point

pointY - the y coordinate of the point

x0 - the x coordinate of the first point on the line

y0 - the y coordinate of the first point on the line

x1 - the x coordinate of the second point on the line

y1 - the y coordinate of the second point on the line

Returns:

the distance between the point and the line

distancePointLine

public static float distancePointLine(float pX,
                                      float pY,
                                      float pZ,
                                      float x0,
                                      float y0,
                                      float z0,
                                      float x1,
                                      float y1,
                                      float z1)

Compute the distance of the given point (pX, pY, pZ) to the line defined by the two points (x0, y0, z0) and (x1, y1, z1).

Reference: http://mathworld.wolfram.com

Parameters:

pX - the x coordinate of the point

pY - the y coordinate of the point

pZ - the z coordinate of the point

x0 - the x coordinate of the first point on the line

y0 - the y coordinate of the first point on the line

z0 - the z coordinate of the first point on the line

x1 - the x coordinate of the second point on the line

y1 - the y coordinate of the second point on the line

z1 - the z coordinate of the second point on the line

Returns:

the distance between the point and the line

intersectRayLine

public static float intersectRayLine(float originX,
                                     float originY,
                                     float dirX,
                                     float dirY,
                                     float pointX,
                                     float pointY,
                                     float normalX,
                                     float normalY,
                                     float epsilon)

Test whether the ray with given origin (originX, originY) and direction (dirX, dirY) intersects the line containing the given point (pointX, pointY) and having the normal (normalX, normalY), and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point.

This method returns -1.0 if the ray does not intersect the line, because it is either parallel to the line or its direction points away from the line or the ray's origin is on the negative side of the line (i.e. the line's normal points away from the ray's origin).

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

pointX - the x coordinate of a point on the line

pointY - the y coordinate of a point on the line

normalX - the x coordinate of the line's normal

normalY - the y coordinate of the line's normal

epsilon - some small epsilon for when the ray is parallel to the line

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if the ray intersects the line; -1.0 otherwise

intersectRayLine

public static float intersectRayLine(org.joml.Vector2fc origin,
                                     org.joml.Vector2fc dir,
                                     org.joml.Vector2fc point,
                                     org.joml.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.

This method returns -1.0 if the ray does not intersect the line, because it is either parallel to the line or its direction points away from the line or the ray's origin is on the negative side of the line (i.e. the line's normal points away from the ray's origin).

Parameters:

origin - the ray's origin

dir - the ray's direction

point - a point on the line

normal - the line's normal

epsilon - some small epsilon for when the ray is parallel to the line

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if the ray intersects the line; -1.0 otherwise

intersectRayLineSegment

public static float intersectRayLineSegment(float originX,
                                            float originY,
                                            float dirX,
                                            float dirY,
                                            float aX,
                                            float aY,
                                            float bX,
                                            float bY)

Determine whether the ray with given origin (originX, originY) and direction (dirX, dirY) intersects the undirected line segment given by the two end points (aX, bY) and (bX, bY), and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if any.

This method returns -1.0 if the ray does not intersect the line segment.

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

aX - the x coordinate of the line segment's first end point

aY - the y coordinate of the line segment's first end point

bX - the x coordinate of the line segment's second end point

bY - the y coordinate of the line segment's second end point

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if the ray intersects the line segment; -1.0 otherwise

See Also:

intersectRayLineSegment(Vector2fc, Vector2fc, Vector2fc, Vector2fc)

intersectRayLineSegment

public static float intersectRayLineSegment(org.joml.Vector2fc origin,
                                            org.joml.Vector2fc dir,
                                            org.joml.Vector2fc a,
                                            org.joml.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.

This method returns -1.0 if the ray does not intersect the line segment.

Parameters:

origin - the ray's origin

dir - the ray's direction

a - the line segment's first end point

b - the line segment's second end point

Returns:

the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point, if the ray intersects the line segment; -1.0 otherwise

See Also:

intersectRayLineSegment(float, float, float, float, float, float, float, float)

testAarCircle

public static boolean testAarCircle(float minX,
                                    float minY,
                                    float maxX,
                                    float maxY,
                                    float centerX,
                                    float centerY,
                                    float radiusSquared)

Test whether the axis-aligned rectangle with minimum corner (minX, minY) and maximum corner (maxX, maxY) intersects the circle with the given center (centerX, centerY) and square radius radiusSquared.

Reference: http://stackoverflow.com

Parameters:

minX - the x coordinate of the minimum corner of the axis-aligned rectangle

minY - the y coordinate of the minimum corner of the axis-aligned rectangle

maxX - the x coordinate of the maximum corner of the axis-aligned rectangle

maxY - the y coordinate of the maximum corner of the axis-aligned rectangle

centerX - the x coordinate of the circle's center

centerY - the y coordinate of the circle's center

radiusSquared - the square of the circle's radius

Returns:

true iff the axis-aligned rectangle intersects the circle; false otherwise

testAarCircle

public static boolean testAarCircle(org.joml.Vector2fc min,
                                    org.joml.Vector2fc max,
                                    org.joml.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.

Reference: http://stackoverflow.com

Parameters:

min - the minimum corner of the axis-aligned rectangle

max - the maximum corner of the axis-aligned rectangle

center - the circle's center

radiusSquared - the squared of the circle's radius

Returns:

true iff the axis-aligned rectangle intersects the circle; false otherwise

findClosestPointOnTriangle

public static int findClosestPointOnTriangle(float v0X,
                                             float v0Y,
                                             float v1X,
                                             float v1Y,
                                             float v2X,
                                             float v2Y,
                                             float pX,
                                             float pY,
                                             org.joml.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.

Additionally, this method returns whether the closest point is a vertex (POINT_ON_TRIANGLE_VERTEX_0, POINT_ON_TRIANGLE_VERTEX_1, POINT_ON_TRIANGLE_VERTEX_2) of the triangle, lies on an edge (POINT_ON_TRIANGLE_EDGE_01, POINT_ON_TRIANGLE_EDGE_12, POINT_ON_TRIANGLE_EDGE_20) or on the face of the triangle.

Reference: Book "Real-Time Collision Detection" chapter 5.1.5 "Closest Point on Triangle to Point"

Parameters:

v0X - the x coordinate of the first vertex of the triangle

v0Y - the y coordinate of the first vertex of the triangle

v1X - the x coordinate of the second vertex of the triangle

v1Y - the y coordinate of the second vertex of the triangle

v2X - the x coordinate of the third vertex of the triangle

v2Y - the y coordinate of the third vertex of the triangle

pX - the x coordinate of the point

pY - the y coordinate of the point

result - will hold the closest point

Returns:

one of POINT_ON_TRIANGLE_VERTEX_0, POINT_ON_TRIANGLE_VERTEX_1, POINT_ON_TRIANGLE_VERTEX_2, POINT_ON_TRIANGLE_EDGE_01, POINT_ON_TRIANGLE_EDGE_12, POINT_ON_TRIANGLE_EDGE_20 or POINT_ON_TRIANGLE_FACE

findClosestPointOnTriangle

public static int findClosestPointOnTriangle(org.joml.Vector2fc v0,
                                             org.joml.Vector2fc v1,
                                             org.joml.Vector2fc v2,
                                             org.joml.Vector2fc p,
                                             org.joml.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.

Additionally, this method returns whether the closest point is a vertex (POINT_ON_TRIANGLE_VERTEX_0, POINT_ON_TRIANGLE_VERTEX_1, POINT_ON_TRIANGLE_VERTEX_2) of the triangle, lies on an edge (POINT_ON_TRIANGLE_EDGE_01, POINT_ON_TRIANGLE_EDGE_12, POINT_ON_TRIANGLE_EDGE_20) or on the face of the triangle.

Reference: Book "Real-Time Collision Detection" chapter 5.1.5 "Closest Point on Triangle to Point"

Parameters:

v0 - the first vertex of the triangle

v1 - the second vertex of the triangle

v2 - the third vertex of the triangle

p - the point

result - will hold the closest point

Returns:

one of POINT_ON_TRIANGLE_VERTEX_0, POINT_ON_TRIANGLE_VERTEX_1, POINT_ON_TRIANGLE_VERTEX_2, POINT_ON_TRIANGLE_EDGE_01, POINT_ON_TRIANGLE_EDGE_12, POINT_ON_TRIANGLE_EDGE_20 or POINT_ON_TRIANGLE_FACE

intersectRayCircle

public static boolean intersectRayCircle(float originX,
                                         float originY,
                                         float dirX,
                                         float dirY,
                                         float centerX,
                                         float centerY,
                                         float radiusSquared,
                                         org.joml.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.

This method returns true for a ray whose origin lies inside the circle.

Reference: http://www.scratchapixel.com/

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

centerX - the x coordinate of the circle's center

centerY - the y coordinate of the circle's center

radiusSquared - the circle radius squared

result - a vector that will contain the values of the parameter t in the ray equation p(t) = origin + t * dir for both points (near, far) of intersections with the circle

Returns:

true if the ray intersects the circle; false otherwise

intersectRayCircle

public static boolean intersectRayCircle(org.joml.Vector2fc origin,
                                         org.joml.Vector2fc dir,
                                         org.joml.Vector2fc center,
                                         float radiusSquared,
                                         org.joml.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.

This method returns true for a ray whose origin lies inside the circle.

Reference: http://www.scratchapixel.com/

Parameters:

origin - the ray's origin

dir - the ray's direction

center - the circle's center

radiusSquared - the circle radius squared

result - a vector that will contain the values of the parameter t in the ray equation p(t) = origin + t * dir for both points (near, far) of intersections with the circle

Returns:

true if the ray intersects the circle; false otherwise

testRayCircle

public static boolean testRayCircle(float originX,
                                    float originY,
                                    float dirX,
                                    float dirY,
                                    float centerX,
                                    float centerY,
                                    float radiusSquared)

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.

This method returns true for a ray whose origin lies inside the circle.

Reference: http://www.scratchapixel.com/

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

centerX - the x coordinate of the circle's center

centerY - the y coordinate of the circle's center

radiusSquared - the circle radius squared

Returns:

true if the ray intersects the circle; false otherwise

testRayCircle

public static boolean testRayCircle(org.joml.Vector2fc origin,
                                    org.joml.Vector2fc dir,
                                    org.joml.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.

This method returns true for a ray whose origin lies inside the circle.

Reference: http://www.scratchapixel.com/

Parameters:

origin - the ray's origin

dir - the ray's direction

center - the circle's center

radiusSquared - the circle radius squared

Returns:

true if the ray intersects the circle; false otherwise

intersectRayAar

public static int intersectRayAar(float originX,
                                  float originY,
                                  float dirX,
                                  float dirY,
                                  float minX,
                                  float minY,
                                  float maxX,
                                  float maxY,
                                  org.joml.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.

This method also detects an intersection for a ray whose origin lies inside the axis-aligned rectangle.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

minX - the x coordinate of the minimum corner of the axis-aligned rectangle

minY - the y coordinate of the minimum corner of the axis-aligned rectangle

maxX - the x coordinate of the maximum corner of the axis-aligned rectangle

maxY - the y coordinate of the maximum corner of the axis-aligned rectangle

result - a vector which will hold the values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection

Returns:

the side on which the near intersection occurred as one of AAR_SIDE_MINX, AAR_SIDE_MINY, AAR_SIDE_MAXX or AAR_SIDE_MAXY; or -1 if the ray does not intersect the axis-aligned rectangle;

See Also:

intersectRayAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f)

intersectRayAar

public static int intersectRayAar(org.joml.Vector2fc origin,
                                  org.joml.Vector2fc dir,
                                  org.joml.Vector2fc min,
                                  org.joml.Vector2fc max,
                                  org.joml.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.

This method also detects an intersection for a ray whose origin lies inside the axis-aligned rectangle.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

origin - the ray's origin

dir - the ray's direction

min - the minimum corner of the axis-aligned rectangle

max - the maximum corner of the axis-aligned rectangle

result - a vector which will hold the values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection

Returns:

the side on which the near intersection occurred as one of AAR_SIDE_MINX, AAR_SIDE_MINY, AAR_SIDE_MAXX or AAR_SIDE_MAXY; or -1 if the ray does not intersect the axis-aligned rectangle;

See Also:

intersectRayAar(float, float, float, float, float, float, float, float, Vector2f)

intersectLineSegmentAar

public static int intersectLineSegmentAar(float p0X,
                                          float p0Y,
                                          float p1X,
                                          float p1Y,
                                          float minX,
                                          float minY,
                                          float maxX,
                                          float maxY,
                                          org.joml.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.

This method also detects an intersection of a line segment whose either end point lies inside the axis-aligned rectangle.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

p0X - the x coordinate of the line segment's first end point

p0Y - the y coordinate of the line segment's first end point

p1X - the x coordinate of the line segment's second end point

p1Y - the y coordinate of the line segment's second end point

minX - the x coordinate of the minimum corner of the axis-aligned rectangle

minY - the y coordinate of the minimum corner of the axis-aligned rectangle

maxX - the x coordinate of the maximum corner of the axis-aligned rectangle

maxY - the y coordinate of the maximum corner of the axis-aligned rectangle

result - a vector which will hold the values of the parameter t in the ray equation p(t) = p0 + t * (p1 - p0) of the near and far point of intersection

Returns:

INSIDE if the line segment lies completely inside of the axis-aligned rectangle; or OUTSIDE if the line segment lies completely outside of the axis-aligned rectangle; or ONE_INTERSECTION if one of the end points of the line segment lies inside of the axis-aligned rectangle; or TWO_INTERSECTION if the line segment intersects two edges of the axis-aligned rectangle or lies on one edge of the rectangle

See Also:

intersectLineSegmentAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc, Vector2f)

intersectLineSegmentAar

public static int intersectLineSegmentAar(org.joml.Vector2fc p0,
                                          org.joml.Vector2fc p1,
                                          org.joml.Vector2fc min,
                                          org.joml.Vector2fc max,
                                          org.joml.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.

This method also detects an intersection of a line segment whose either end point lies inside the axis-aligned rectangle.

Reference: An Efficient and Robust Ray–Box Intersection #see intersectLineSegmentAar(float, float, float, float, float, float, float, float, Vector2f)

Parameters:

p0 - the line segment's first end point

p1 - the line segment's second end point

min - the minimum corner of the axis-aligned rectangle

max - the maximum corner of the axis-aligned rectangle

result - a vector which will hold the values of the parameter t in the ray equation p(t) = p0 + t * (p1 - p0) of the near and far point of intersection

Returns:

INSIDE if the line segment lies completely inside of the axis-aligned rectangle; or OUTSIDE if the line segment lies completely outside of the axis-aligned rectangle; or ONE_INTERSECTION if one of the end points of the line segment lies inside of the axis-aligned rectangle; or TWO_INTERSECTION if the line segment intersects two edges of the axis-aligned rectangle

testRayAar

public static boolean testRayAar(float originX,
                                 float originY,
                                 float dirX,
                                 float dirY,
                                 float minX,
                                 float minY,
                                 float maxX,
                                 float maxY)

Test whether the given ray with the origin (originX, originY) and direction (dirX, dirY) intersects the given axis-aligned rectangle given as its minimum corner (minX, minY) and maximum corner (maxX, maxY).

This method returns true for a ray whose origin lies inside the axis-aligned rectangle.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

minX - the x coordinate of the minimum corner of the axis-aligned rectangle

minY - the y coordinate of the minimum corner of the axis-aligned rectangle

maxX - the x coordinate of the maximum corner of the axis-aligned rectangle

maxY - the y coordinate of the maximum corner of the axis-aligned rectangle

Returns:

true if the given ray intersects the axis-aligned rectangle; false otherwise

See Also:

testRayAar(Vector2fc, Vector2fc, Vector2fc, Vector2fc)

testRayAar

public static boolean testRayAar(org.joml.Vector2fc origin,
                                 org.joml.Vector2fc dir,
                                 org.joml.Vector2fc min,
                                 org.joml.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.

This method returns true for a ray whose origin lies inside the axis-aligned rectangle.

Reference: An Efficient and Robust Ray–Box Intersection

Parameters:

origin - the ray's origin

dir - the ray's direction

min - the minimum corner of the axis-aligned rectangle

max - the maximum corner of the axis-aligned rectangle

Returns:

true if the given ray intersects the axis-aligned rectangle; false otherwise

See Also:

testRayAar(float, float, float, float, float, float, float, float)

testPointTriangle

public static boolean testPointTriangle(float pX,
                                        float pY,
                                        float v0X,
                                        float v0Y,
                                        float v1X,
                                        float v1Y,
                                        float v2X,
                                        float v2Y)

Test whether the given point (pX, pY) lies inside the triangle with the vertices (v0X, v0Y), (v1X, v1Y), (v2X, v2Y).

Parameters:

pX - the x coordinate of the point

pY - the y coordinate of the point

v0X - the x coordinate of the first vertex of the triangle

v0Y - the y coordinate of the first vertex of the triangle

v1X - the x coordinate of the second vertex of the triangle

v1Y - the y coordinate of the second vertex of the triangle

v2X - the x coordinate of the third vertex of the triangle

v2Y - the y coordinate of the third vertex of the triangle

Returns:

true iff the point lies inside the triangle; false otherwise

testPointTriangle

public static boolean testPointTriangle(org.joml.Vector2fc point,
                                        org.joml.Vector2fc v0,
                                        org.joml.Vector2fc v1,
                                        org.joml.Vector2fc v2)

Test whether the given point lies inside the triangle with the vertices v0, v1, v2.

Parameters:

v0 - the first vertex of the triangle

v1 - the second vertex of the triangle

v2 - the third vertex of the triangle

point - the point

Returns:

true iff the point lies inside the triangle; false otherwise

testPointAar

public static boolean testPointAar(float pX,
                                   float pY,
                                   float minX,
                                   float minY,
                                   float maxX,
                                   float maxY)

Test whether the given point (pX, pY) lies inside the axis-aligned rectangle with the minimum corner (minX, minY) and maximum corner (maxX, maxY).

Parameters:

pX - the x coordinate of the point

pY - the y coordinate of the point

minX - the x coordinate of the minimum corner of the axis-aligned rectangle

minY - the y coordinate of the minimum corner of the axis-aligned rectangle

maxX - the x coordinate of the maximum corner of the axis-aligned rectangle

maxY - the y coordinate of the maximum corner of the axis-aligned rectangle

Returns:

true iff the point lies inside the axis-aligned rectangle; false otherwise

testPointCircle

public static boolean testPointCircle(float pX,
                                      float pY,
                                      float centerX,
                                      float centerY,
                                      float radiusSquared)

Test whether the point (pX, pY) lies inside the circle with center (centerX, centerY) and square radius radiusSquared.

Parameters:

pX - the x coordinate of the point

pY - the y coordinate of the point

centerX - the x coordinate of the circle's center

centerY - the y coordinate of the circle's center

radiusSquared - the square radius of the circle

Returns:

true iff the point lies inside the circle; false otherwise

testCircleTriangle

public static boolean testCircleTriangle(float centerX,
                                         float centerY,
                                         float radiusSquared,
                                         float v0X,
                                         float v0Y,
                                         float v1X,
                                         float v1Y,
                                         float v2X,
                                         float v2Y)

Test whether the circle with center (centerX, centerY) and square radius radiusSquared intersects the triangle with counter-clockwise vertices (v0X, v0Y), (v1X, v1Y), (v2X, v2Y).

The vertices of the triangle must be specified in counter-clockwise order.

Reference: http://www.phatcode.net/

Parameters:

centerX - the x coordinate of the circle's center

centerY - the y coordinate of the circle's center

radiusSquared - the square radius of the circle

v0X - the x coordinate of the first vertex of the triangle

v0Y - the y coordinate of the first vertex of the triangle

v1X - the x coordinate of the second vertex of the triangle

v1Y - the y coordinate of the second vertex of the triangle

v2X - the x coordinate of the third vertex of the triangle

v2Y - the y coordinate of the third vertex of the triangle

Returns:

true iff the circle intersects the triangle; false otherwise

testCircleTriangle

public static boolean testCircleTriangle(org.joml.Vector2fc center,
                                         float radiusSquared,
                                         org.joml.Vector2fc v0,
                                         org.joml.Vector2fc v1,
                                         org.joml.Vector2fc v2)

Test whether the circle with given center and square radius radiusSquared intersects the triangle with counter-clockwise vertices v0, v1, v2.

The vertices of the triangle must be specified in counter-clockwise order.

Reference: http://www.phatcode.net/

Parameters:

center - the circle's center

radiusSquared - the square radius of the circle

v0 - the first vertex of the triangle

v1 - the second vertex of the triangle

v2 - the third vertex of the triangle

Returns:

true iff the circle intersects the triangle; false otherwise

intersectPolygonRay

public static int intersectPolygonRay(float[] verticesXY,
                                      float originX,
                                      float originY,
                                      float dirX,
                                      float dirY,
                                      org.joml.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.

If the polygon intersects the ray, this method returns the index of the polygon edge intersecting the ray, that is, the index of the first vertex of the directed line segment. The second vertex is always that index + 1, modulus the number of polygon vertices.

Parameters:

verticesXY - the sequence of (x, y) coordinate pairs of all vertices of the polygon

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

p - will hold the point of intersection

Returns:

the index of the first vertex of the polygon edge that intersects the ray; or -1 if the ray does not intersect the polygon

intersectPolygonRay

public static int intersectPolygonRay(org.joml.Vector2fc[] vertices,
                                      float originX,
                                      float originY,
                                      float dirX,
                                      float dirY,
                                      org.joml.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.

If the polygon intersects the ray, this method returns the index of the polygon edge intersecting the ray, that is, the index of the first vertex of the directed line segment. The second vertex is always that index + 1, modulus the number of polygon vertices.

Parameters:

vertices - the sequence of (x, y) coordinate pairs of all vertices of the polygon

originX - the x coordinate of the ray's origin

originY - the y coordinate of the ray's origin

dirX - the x coordinate of the ray's direction

dirY - the y coordinate of the ray's direction

p - will hold the point of intersection

Returns:

the index of the first vertex of the polygon edge that intersects the ray; or -1 if the ray does not intersect the polygon

intersectLineLine

public static boolean intersectLineLine(float ps1x,
                                        float ps1y,
                                        float pe1x,
                                        float pe1y,
                                        float ps2x,
                                        float ps2y,
                                        float pe2x,
                                        float pe2y,
                                        org.joml.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.

Parameters:

ps1x - the x coordinate of the first point on the first line

ps1y - the y coordinate of the first point on the first line

pe1x - the x coordinate of the second point on the first line

pe1y - the y coordinate of the second point on the first line

ps2x - the x coordinate of the first point on the second line

ps2y - the y coordinate of the first point on the second line

pe2x - the x coordinate of the second point on the second line

pe2y - the y coordinate of the second point on the second line

p - will hold the point of intersection

Returns:

true iff the two lines intersect; false otherwise

testPolygonPolygon

public static boolean testPolygonPolygon(org.joml.Vector2f[] v1s,
                                         org.joml.Vector2f[] v2s)

Test if the two polygons, given via their vertices, intersect.

Parameters:

v1s - the vertices of the first polygon

v2s - the vertices of the second polygon

Returns:

true if the polygons intersect; false otherwise