java.lang.Object
- org.joml.Intersectiond

```
public class Intersectiond
extends java.lang.Object
```
Contains intersection and distance tests for some 2D and 3D geometric primitives.

Author:

Kai Burjack

Field Summary

Fields
Modifier and Type	Field	Description
`static int`	`AAR_SIDE_MAXX`	Return value of `intersectRayAar(double, double, double, double, double, double, double, double, Vector2d)` and `intersectRayAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` 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(double, double, double, double, double, double, double, double, Vector2d)` and `intersectRayAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` 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(double, double, double, double, double, double, double, double, Vector2d)` and `intersectRayAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` 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(double, double, double, double, double, double, double, double, Vector2d)` and `intersectRayAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector2d)` and `intersectLineSegmentAab(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d)` to indicate that the line segment lies completely inside of the axis-aligned box; or return value of `intersectLineSegmentAar(double, double, double, double, double, double, double, double, Vector2d)` and `intersectLineSegmentAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` to indicate that the line segment lies completely inside of the axis-aligned rectangle.
`static int`	`ONE_INTERSECTION`	Return value of `intersectLineSegmentAab(double, double, double, double, double, double, double, double, double, double, double, double, Vector2d)` and `intersectLineSegmentAab(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d)` to indicate that one end point of the line segment lies inside of the axis-aligned box; or return value of `intersectLineSegmentAar(double, double, double, double, double, double, double, double, Vector2d)` and `intersectLineSegmentAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` to indicate that one end point of the line segment lies inside of the axis-aligned rectangle.
`static int`	`OUTSIDE`	Return value of `intersectLineSegmentAab(double, double, double, double, double, double, double, double, double, double, double, double, Vector2d)` and `intersectLineSegmentAab(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d)` to indicate that the line segment does not intersect the axis-aligned box; or return value of `intersectLineSegmentAar(double, double, double, double, double, double, double, double, Vector2d)` and `intersectLineSegmentAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` to indicate that the line segment does not intersect the axis-aligned rectangle.
`static int`	`POINT_ON_TRIANGLE_EDGE_01`	Return value of `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d)`, `findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d)`, `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d)` and `findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` or `intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d)` 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d)`, `findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d)`, `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d)` and `findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` or `intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d)` 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d)`, `findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d)`, `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d)` and `findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` or `intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d)` 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d)`, `findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d)`, `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d)` and `findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` or `intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d)` to signal that the closest point lies on the face of the triangle.
`static int`	`POINT_ON_TRIANGLE_VERTEX_0`	Return value of `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d)`, `findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d)`, `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d)` and `findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` or `intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d)` to signal that the closest point is the first vertex of the triangle.
`static int`	`POINT_ON_TRIANGLE_VERTEX_1`	Return value of `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d)`, `findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d)`, `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d)` and `findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` or `intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d)` to signal that the closest point is the second vertex of the triangle.
`static int`	`POINT_ON_TRIANGLE_VERTEX_2`	Return value of `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d)`, `findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d)`, `findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d)` and `findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` or `intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d)` to signal that the closest point is the third vertex of the triangle.
`static int`	`TWO_INTERSECTION`	Return value of `intersectLineSegmentAab(double, double, double, double, double, double, double, double, double, double, double, double, Vector2d)` and `intersectLineSegmentAab(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d)` 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(double, double, double, double, double, double, double, double, Vector2d)` and `intersectLineSegmentAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)` 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 Description

Intersectiond()

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static double`	`distancePointLine(double pointX, double pointY, double a, double b, double c)`	Determine the signed distance of the given point `(pointX, pointY)` to the line specified via its general plane equation ax + by + c = 0.
`static double`	`distancePointLine(double pointX, double pointY, double x0, double y0, double x1, double 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 double`	`distancePointLine(double pX, double pY, double pZ, double x0, double y0, double z0, double x1, double y1, double 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 double`	`distancePointPlane(double pointX, double pointY, double pointZ, double a, double b, double c, double d)`	Determine the signed distance of the given point `(pointX, pointY, pointZ)` to the plane specified via its general plane equation ax + by + cz + d = 0*.
`static double`	`distancePointPlane(double pointX, double pointY, double pointZ, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double 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 Vector3d`	`findClosestPointOnLineSegment(double aX, double aY, double aZ, double bX, double bY, double bZ, double pX, double pY, double pZ, Vector3d 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 Vector3d`	`findClosestPointOnPlane(double aX, double aY, double aZ, double nX, double nY, double nZ, double pX, double pY, double pZ, Vector3d 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 Vector3d`	`findClosestPointOnRectangle(double aX, double aY, double aZ, double bX, double bY, double bZ, double cX, double cY, double cZ, double pX, double pY, double pZ, Vector3d 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(double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, double pX, double pY, double pZ, Vector3d 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(double v0X, double v0Y, double v1X, double v1Y, double v2X, double v2Y, double pX, double pY, Vector2d 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(Vector2dc v0, Vector2dc v1, Vector2dc v2, Vector2dc p, Vector2d 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(Vector3dc v0, Vector3dc v1, Vector3dc v2, Vector3dc p, Vector3d 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 double`	`findClosestPointsLineSegments(double a0X, double a0Y, double a0Z, double a1X, double a1Y, double a1Z, double b0X, double b0Y, double b0Z, double b1X, double b1Y, double b1Z, Vector3d resultA, Vector3d 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 double`	`findClosestPointsLineSegmentTriangle(double aX, double aY, double aZ, double bX, double bY, double bZ, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, Vector3d lineSegmentResult, Vector3d triangleResult)`	Find the closest points on a line segment and a triangle.
`static boolean`	`intersectCircleCircle(double aX, double aY, double radiusSquaredA, double bX, double bY, double radiusSquaredB, Vector3d 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(Vector2dc centerA, double radiusSquaredA, Vector2dc centerB, double radiusSquaredB, Vector3d 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(double x0, double y0, double x1, double y1, double centerX, double centerY, double radius, Vector3d 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(double a, double b, double c, double centerX, double centerY, double radius, Vector3d intersectionCenterAndHL)`	Test whether the line with the general line equation ax + by + 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(double ps1x, double ps1y, double pe1x, double pe1y, double ps2x, double ps2y, double pe2x, double pe2y, Vector2d 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(double p0X, double p0Y, double p0Z, double p1X, double p1Y, double p1Z, double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vector2d 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(Vector3dc p0, Vector3dc p1, Vector3dc min, Vector3dc max, Vector2d 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(double p0X, double p0Y, double p1X, double p1Y, double minX, double minY, double maxX, double maxY, Vector2d 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(Vector2dc p0, Vector2dc p1, Vector2dc min, Vector2dc max, Vector2d 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(double p0X, double p0Y, double p0Z, double p1X, double p1Y, double p1Z, double a, double b, double c, double d, Vector3d 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 ax + by + cz + d = 0*, and return the point of intersection.
`static boolean`	`intersectLineSegmentTriangle(double p0X, double p0Y, double p0Z, double p1X, double p1Y, double p1Z, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, double epsilon, Vector3d 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(Vector3dc p0, Vector3dc p1, Vector3dc v0, Vector3dc v1, Vector3dc v2, double epsilon, Vector3d 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(double a, double b, double c, double d, double centerX, double centerY, double centerZ, double radius, Vector4d intersectionCenterAndRadius)`	Test whether the plane with the general plane equation ax + by + cz + 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(double a, double b, double c, double d, double cX, double cY, double cZ, double radius, double vX, double vY, double vZ, Vector4d pointAndTime)`	Test whether the plane with the general plane equation ax + by + cz + 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(double[] verticesXY, double originX, double originY, double dirX, double dirY, Vector2d 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(Vector2dc[] vertices, double originX, double originY, double dirX, double dirY, Vector2d 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(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vector2d 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(Vector3dc origin, Vector3dc dir, Vector3dc min, Vector3dc max, Vector2d 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(double originX, double originY, double dirX, double dirY, double minX, double minY, double maxX, double maxY, Vector2d 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(Vector2dc origin, Vector2dc dir, Vector2dc min, Vector2dc max, Vector2d 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(double originX, double originY, double dirX, double dirY, double centerX, double centerY, double radiusSquared, Vector2d 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(Vector2dc origin, Vector2dc dir, Vector2dc center, double radiusSquared, Vector2d 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 double`	`intersectRayLine(double originX, double originY, double dirX, double dirY, double pointX, double pointY, double normalX, double normalY, double 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 double`	`intersectRayLine(Vector2dc origin, Vector2dc dir, Vector2dc point, Vector2dc normal, double 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 double`	`intersectRayLineSegment(double originX, double originY, double dirX, double dirY, double aX, double aY, double bX, double 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 double`	`intersectRayLineSegment(Vector2dc origin, Vector2dc dir, Vector2dc a, Vector2dc 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 double`	`intersectRayPlane(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, double a, double b, double c, double d, double 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 ax + by + cz + d = 0, and return the value of the parameter t in the ray equation p(t) = origin + t * dir* of the intersection point.
`static double`	`intersectRayPlane(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, double pointX, double pointY, double pointZ, double normalX, double normalY, double normalZ, double 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 double`	`intersectRayPlane(Vector3dc origin, Vector3dc dir, Vector3dc point, Vector3dc normal, double 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(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, double centerX, double centerY, double centerZ, double radiusSquared, Vector2d 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(Vector3dc origin, Vector3dc dir, Vector3dc center, double radiusSquared, Vector2d 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 double`	`intersectRayTriangle(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, double 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 double`	`intersectRayTriangle(Vector3dc origin, Vector3dc dir, Vector3dc v0, Vector3dc v1, Vector3dc v2, double 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 double`	`intersectRayTriangleFront(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, double 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 double`	`intersectRayTriangleFront(Vector3dc origin, Vector3dc dir, Vector3dc v0, Vector3dc v1, Vector3dc v2, double 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(double aX, double aY, double aZ, double radiusSquaredA, double bX, double bY, double bZ, double radiusSquaredB, Vector4d 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(Vector3dc centerA, double radiusSquaredA, Vector3dc centerB, double radiusSquaredB, Vector4d 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(double sX, double sY, double sZ, double sR, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, Vector3d 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(double centerX, double centerY, double centerZ, double radius, double velX, double velY, double velZ, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, double epsilon, double maxT, Vector4d 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(double minXA, double minYA, double minZA, double maxXA, double maxYA, double maxZA, double minXB, double minYB, double minZB, double maxXB, double maxYB, double 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(Vector3dc minA, Vector3dc maxA, Vector3dc minB, Vector3dc 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(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, double a, double b, double c, double 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 ax + by + cz + d = 0*.
`static boolean`	`testAabPlane(Vector3dc min, Vector3dc max, double a, double b, double c, double d)`	Test whether the axis-aligned box with minimum corner `min` and maximum corner `max` intersects the plane with the general equation ax + by + cz + d = 0*.
`static boolean`	`testAabSphere(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, double centerX, double centerY, double centerZ, double 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(Vector3dc min, Vector3dc max, Vector3dc center, double 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(double minXA, double minYA, double maxXA, double maxYA, double minXB, double minYB, double maxXB, double 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(Vector2dc minA, Vector2dc maxA, Vector2dc minB, Vector2dc 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(double minX, double minY, double maxX, double maxY, double centerX, double centerY, double 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(Vector2dc min, Vector2dc max, Vector2dc center, double 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(double minX, double minY, double maxX, double maxY, double a, double b, double c)`	Test whether the axis-aligned rectangle with minimum corner `(minX, minY)` and maximum corner `(maxX, maxY)` intersects the line with the general equation ax + by + c = 0.
`static boolean`	`testAarLine(double minX, double minY, double maxX, double maxY, double x0, double y0, double x1, double 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(Vector2dc min, Vector2dc max, double a, double b, double c)`	Test whether the axis-aligned rectangle with minimum corner `min` and maximum corner `max` intersects the line with the general equation ax + by + c = 0.
`static boolean`	`testCircleCircle(double aX, double aY, double rA, double bX, double bY, double 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(Vector2dc centerA, double radiusSquaredA, Vector2dc centerB, double 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(double centerX, double centerY, double radiusSquared, double v0X, double v0Y, double v1X, double v1Y, double v2X, double 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(Vector2dc center, double radiusSquared, Vector2dc v0, Vector2dc v1, Vector2dc 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(double a, double b, double c, double centerX, double centerY, double radius)`	Test whether the line with the general line equation ax + by + c = 0 intersects the circle with center `(centerX, centerY)` and `radius`.
`static boolean`	`testLineSegmentSphere(double p0X, double p0Y, double p0Z, double p1X, double p1Y, double p1Z, double centerX, double centerY, double centerZ, double 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(Vector3dc p0, Vector3dc p1, Vector3dc center, double 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(double p0X, double p0Y, double p0Z, double p1X, double p1Y, double p1Z, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, double 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(Vector3dc p0, Vector3dc p1, Vector3dc v0, Vector3dc v1, Vector3dc v2, double 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(double aX, double aY, double maX, double maY, double aR, double bX, double bY, double 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(Vector2d centerA, Vector2d moveA, double aR, Vector2d centerB, double 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(double b0cX, double b0cY, double b0cZ, double b0uXx, double b0uXy, double b0uXz, double b0uYx, double b0uYy, double b0uYz, double b0uZx, double b0uZy, double b0uZz, double b0hsX, double b0hsY, double b0hsZ, double b1cX, double b1cY, double b1cZ, double b1uXx, double b1uXy, double b1uXz, double b1uYx, double b1uYy, double b1uYz, double b1uZx, double b1uZy, double b1uZz, double b1hsX, double b1hsY, double b1hsZ)`	Test whether two oriented boxes given via their center position, orientation and half-size, intersect.
`static boolean`	`testObOb(Vector3d b0c, Vector3d b0uX, Vector3d b0uY, Vector3d b0uZ, Vector3d b0hs, Vector3d b1c, Vector3d b1uX, Vector3d b1uY, Vector3d b1uZ, Vector3d b1hs)`	Test whether two oriented boxes given via their center position, orientation and half-size, intersect.
`static boolean`	`testPlaneSphere(double a, double b, double c, double d, double centerX, double centerY, double centerZ, double radius)`	Test whether the plane with the general plane equation ax + by + cz + d = 0* intersects the sphere with center `(centerX, centerY, centerZ)` and `radius`.
`static boolean`	`testPlaneSweptSphere(double a, double b, double c, double d, double t0X, double t0Y, double t0Z, double r, double t1X, double t1Y, double t1Z)`	Test whether the plane with the general plane equation ax + by + cz + d = 0* intersects the sphere moving from center position `(t0X, t0Y, t0Z)` to `(t1X, t1Y, t1Z)` and having the given `radius`.
`static boolean`	`testPointAar(double pX, double pY, double minX, double minY, double maxX, double 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(double pX, double pY, double centerX, double centerY, double radiusSquared)`	Test whether the point `(pX, pY)` lies inside the circle with center `(centerX, centerY)` and square radius `radiusSquared`.
`static boolean`	`testPointInTriangle(double pX, double pY, double pZ, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double 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(double pX, double pY, double v0X, double v0Y, double v1X, double v1Y, double v2X, double v2Y)`	Test whether the given point `(pX, pY)` lies inside the triangle with the vertices `(v0X, v0Y)`, `(v1X, v1Y)`, `(v2X, v2Y)`.
`static boolean`	`testPointTriangle(Vector2dc point, Vector2dc v0, Vector2dc v1, Vector2dc v2)`	Test whether the given `point` lies inside the triangle with the vertices `v0`, `v1`, `v2`.
`static boolean`	`testPolygonPolygon(Vector2d[] v1s, Vector2d[] v2s)`	Test if the two convex polygons, given via their vertices, intersect.
`static boolean`	`testRayAab(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, double minX, double minY, double minZ, double maxX, double maxY, double 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(Vector3dc origin, Vector3dc dir, Vector3dc min, Vector3dc 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(double originX, double originY, double dirX, double dirY, double minX, double minY, double maxX, double 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(Vector2dc origin, Vector2dc dir, Vector2dc min, Vector2dc 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(double originX, double originY, double dirX, double dirY, double centerX, double centerY, double 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(Vector2dc origin, Vector2dc dir, Vector2dc center, double 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(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, double centerX, double centerY, double centerZ, double 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(Vector3dc origin, Vector3dc dir, Vector3dc center, double 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(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, double 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(Vector3dc origin, Vector3dc dir, Vector3dc v0, Vector3dc v1, Vector3dc v2, double 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(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, double v0X, double v0Y, double v0Z, double v1X, double v1Y, double v1Z, double v2X, double v2Y, double v2Z, double 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(Vector3dc origin, Vector3dc dir, Vector3dc v0, Vector3dc v1, Vector3dc v2, double 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(double aX, double aY, double aZ, double radiusSquaredA, double bX, double bY, double bZ, double 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(Vector3dc centerA, double radiusSquaredA, Vector3dc centerB, double 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d), findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d), findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d) and findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) or intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d) 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d), findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d), findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d) and findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) or intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d) 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d), findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d), findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d) and findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) or intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d) 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d), findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d), findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d) and findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) or intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d) 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d), findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d), findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d) and findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) or intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d) 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d), findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d), findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d) and findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) or intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d) 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector3d), findClosestPointOnTriangle(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3d), findClosestPointOnTriangle(double, double, double, double, double, double, double, double, Vector2d) and findClosestPointOnTriangle(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) or intersectSweptSphereTriangle(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, org.joml.Vector4d) 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(double, double, double, double, double, double, double, double, Vector2d) and intersectRayAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) 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(double, double, double, double, double, double, double, double, Vector2d) and intersectRayAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) 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(double, double, double, double, double, double, double, double, Vector2d) and intersectRayAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) 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(double, double, double, double, double, double, double, double, Vector2d) and intersectRayAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector2d) and intersectLineSegmentAab(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d) to indicate that the line segment does not intersect the axis-aligned box; or return value of intersectLineSegmentAar(double, double, double, double, double, double, double, double, Vector2d) and intersectLineSegmentAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector2d) and intersectLineSegmentAab(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d) to indicate that one end point of the line segment lies inside of the axis-aligned box; or return value of intersectLineSegmentAar(double, double, double, double, double, double, double, double, Vector2d) and intersectLineSegmentAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector2d) and intersectLineSegmentAab(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d) 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(double, double, double, double, double, double, double, double, Vector2d) and intersectLineSegmentAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector2d) and intersectLineSegmentAab(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d) to indicate that the line segment lies completely inside of the axis-aligned box; or return value of intersectLineSegmentAar(double, double, double, double, double, double, double, double, Vector2d) and intersectLineSegmentAar(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d) to indicate that the line segment lies completely inside of the axis-aligned rectangle.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Intersectiond
```
public Intersectiond()
```
- Method Detail
  - testPlaneSphere
```
public static boolean testPlaneSphere(double a,
                                      double b,
                                      double c,
                                      double d,
                                      double centerX,
                                      double centerY,
                                      double centerZ,
                                      double 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
  - intersectPlaneSphere
```
public static boolean intersectPlaneSphere(double a,
                                           double b,
                                           double c,
                                           double d,
                                           double centerX,
                                           double centerY,
                                           double centerZ,
                                           double radius,
                                           Vector4d 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(double a,
                                                double b,
                                                double c,
                                                double d,
                                                double cX,
                                                double cY,
                                                double cZ,
                                                double radius,
                                                double vX,
                                                double vY,
                                                double vZ,
                                                Vector4d 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(double a,
                                           double b,
                                           double c,
                                           double d,
                                           double t0X,
                                           double t0Y,
                                           double t0Z,
                                           double r,
                                           double t1X,
                                           double t1Y,
                                           double 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(double minX,
                                   double minY,
                                   double minZ,
                                   double maxX,
                                   double maxY,
                                   double maxZ,
                                   double a,
                                   double b,
                                   double c,
                                   double 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(Vector3dc min,
                                   Vector3dc max,
                                   double a,
                                   double b,
                                   double c,
                                   double 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(double minXA,
                                 double minYA,
                                 double minZA,
                                 double maxXA,
                                 double maxYA,
                                 double maxZA,
                                 double minXB,
                                 double minYB,
                                 double minZB,
                                 double maxXB,
                                 double maxYB,
                                 double 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(Vector3dc minA,
                                 Vector3dc maxA,
                                 Vector3dc minB,
                                 Vector3dc 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
  - testObOb
```
public static boolean testObOb(Vector3d b0c,
                               Vector3d b0uX,
                               Vector3d b0uY,
                               Vector3d b0uZ,
                               Vector3d b0hs,
                               Vector3d b1c,
                               Vector3d b1uX,
                               Vector3d b1uY,
                               Vector3d b1uZ,
                               Vector3d 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(double b0cX,
                               double b0cY,
                               double b0cZ,
                               double b0uXx,
                               double b0uXy,
                               double b0uXz,
                               double b0uYx,
                               double b0uYy,
                               double b0uYz,
                               double b0uZx,
                               double b0uZy,
                               double b0uZz,
                               double b0hsX,
                               double b0hsY,
                               double b0hsZ,
                               double b1cX,
                               double b1cY,
                               double b1cZ,
                               double b1uXx,
                               double b1uXy,
                               double b1uXz,
                               double b1uYx,
                               double b1uYy,
                               double b1uYz,
                               double b1uZx,
                               double b1uZy,
                               double b1uZz,
                               double b1hsX,
                               double b1hsY,
                               double 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(double aX,
                                            double aY,
                                            double aZ,
                                            double radiusSquaredA,
                                            double bX,
                                            double bY,
                                            double bZ,
                                            double radiusSquaredB,
                                            Vector4d 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(Vector3dc centerA,
                                            double radiusSquaredA,
                                            Vector3dc centerB,
                                            double radiusSquaredB,
                                            Vector4d 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
  - intersectSphereTriangle
```
public static int intersectSphereTriangle(double sX,
                                          double sY,
                                          double sZ,
                                          double sR,
                                          double v0X,
                                          double v0Y,
                                          double v0Z,
                                          double v1X,
                                          double v1Y,
                                          double v1Z,
                                          double v2X,
                                          double v2Y,
                                          double v2Z,
                                          Vector3d 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(double aX,
                                       double aY,
                                       double aZ,
                                       double radiusSquaredA,
                                       double bX,
                                       double bY,
                                       double bZ,
                                       double 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(Vector3dc centerA,
                                       double radiusSquaredA,
                                       Vector3dc centerB,
                                       double 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 double distancePointPlane(double pointX,
                                        double pointY,
                                        double pointZ,
                                        double a,
                                        double b,
                                        double c,
                                        double 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 double distancePointPlane(double pointX,
                                        double pointY,
                                        double pointZ,
                                        double v0X,
                                        double v0Y,
                                        double v0Z,
                                        double v1X,
                                        double v1Y,
                                        double v1Z,
                                        double v2X,
                                        double v2Y,
                                        double 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 double intersectRayPlane(double originX,
                                       double originY,
                                       double originZ,
                                       double dirX,
                                       double dirY,
                                       double dirZ,
                                       double pointX,
                                       double pointY,
                                       double pointZ,
                                       double normalX,
                                       double normalY,
                                       double normalZ,
                                       double 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 double intersectRayPlane(Vector3dc origin,
                                       Vector3dc dir,
                                       Vector3dc point,
                                       Vector3dc normal,
                                       double 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 double intersectRayPlane(double originX,
                                       double originY,
                                       double originZ,
                                       double dirX,
                                       double dirY,
                                       double dirZ,
                                       double a,
                                       double b,
                                       double c,
                                       double d,
                                       double 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(double minX,
                                    double minY,
                                    double minZ,
                                    double maxX,
                                    double maxY,
                                    double maxZ,
                                    double centerX,
                                    double centerY,
                                    double centerZ,
                                    double 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(Vector3dc min,
                                    Vector3dc max,
                                    Vector3dc center,
                                    double 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
  - findClosestPointOnPlane
```
public static Vector3d findClosestPointOnPlane(double aX,
                                               double aY,
                                               double aZ,
                                               double nX,
                                               double nY,
                                               double nZ,
                                               double pX,
                                               double pY,
                                               double pZ,
                                               Vector3d 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 Vector3d findClosestPointOnLineSegment(double aX,
                                                     double aY,
                                                     double aZ,
                                                     double bX,
                                                     double bY,
                                                     double bZ,
                                                     double pX,
                                                     double pY,
                                                     double pZ,
                                                     Vector3d 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 double findClosestPointsLineSegments(double a0X,
                                                   double a0Y,
                                                   double a0Z,
                                                   double a1X,
                                                   double a1Y,
                                                   double a1Z,
                                                   double b0X,
                                                   double b0Y,
                                                   double b0Z,
                                                   double b1X,
                                                   double b1Y,
                                                   double b1Z,
                                                   Vector3d resultA,
                                                   Vector3d 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 double findClosestPointsLineSegmentTriangle(double aX,
                                                          double aY,
                                                          double aZ,
                                                          double bX,
                                                          double bY,
                                                          double bZ,
                                                          double v0X,
                                                          double v0Y,
                                                          double v0Z,
                                                          double v1X,
                                                          double v1Y,
                                                          double v1Z,
                                                          double v2X,
                                                          double v2Y,
                                                          double v2Z,
                                                          Vector3d lineSegmentResult,
                                                          Vector3d 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(double v0X,
                                             double v0Y,
                                             double v0Z,
                                             double v1X,
                                             double v1Y,
                                             double v1Z,
                                             double v2X,
                                             double v2Y,
                                             double v2Z,
                                             double pX,
                                             double pY,
                                             double pZ,
                                             Vector3d 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(Vector3dc v0,
                                             Vector3dc v1,
                                             Vector3dc v2,
                                             Vector3dc p,
                                             Vector3d 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 Vector3d findClosestPointOnRectangle(double aX,
                                                   double aY,
                                                   double aZ,
                                                   double bX,
                                                   double bY,
                                                   double bZ,
                                                   double cX,
                                                   double cY,
                                                   double cZ,
                                                   double pX,
                                                   double pY,
                                                   double pZ,
                                                   Vector3d 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(double centerX,
                                               double centerY,
                                               double centerZ,
                                               double radius,
                                               double velX,
                                               double velY,
                                               double velZ,
                                               double v0X,
                                               double v0Y,
                                               double v0Z,
                                               double v1X,
                                               double v1Y,
                                               double v1Z,
                                               double v2X,
                                               double v2Y,
                                               double v2Z,
                                               double epsilon,
                                               double maxT,
                                               Vector4d 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(double pX,
                                          double pY,
                                          double pZ,
                                          double v0X,
                                          double v0Y,
                                          double v0Z,
                                          double v1X,
                                          double v1Y,
                                          double v1Z,
                                          double v2X,
                                          double v2Y,
                                          double 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(double originX,
                                         double originY,
                                         double originZ,
                                         double dirX,
                                         double dirY,
                                         double dirZ,
                                         double centerX,
                                         double centerY,
                                         double centerZ,
                                         double radiusSquared,
                                         Vector2d 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(Vector3dc origin,
                                         Vector3dc dir,
                                         Vector3dc center,
                                         double radiusSquared,
                                         Vector2d 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
  - testRaySphere
```
public static boolean testRaySphere(double originX,
                                    double originY,
                                    double originZ,
                                    double dirX,
                                    double dirY,
                                    double dirZ,
                                    double centerX,
                                    double centerY,
                                    double centerZ,
                                    double 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(Vector3dc origin,
                                    Vector3dc dir,
                                    Vector3dc center,
                                    double 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
  - testLineSegmentSphere
```
public static boolean testLineSegmentSphere(double p0X,
                                            double p0Y,
                                            double p0Z,
                                            double p1X,
                                            double p1Y,
                                            double p1Z,
                                            double centerX,
                                            double centerY,
                                            double centerZ,
                                            double 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(Vector3dc p0,
                                            Vector3dc p1,
                                            Vector3dc center,
                                            double 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(double originX,
                                      double originY,
                                      double originZ,
                                      double dirX,
                                      double dirY,
                                      double dirZ,
                                      double minX,
                                      double minY,
                                      double minZ,
                                      double maxX,
                                      double maxY,
                                      double maxZ,
                                      Vector2d 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(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d), RayAabIntersection
  - intersectRayAab
```
public static boolean intersectRayAab(Vector3dc origin,
                                      Vector3dc dir,
                                      Vector3dc min,
                                      Vector3dc max,
                                      Vector2d 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(double, double, double, double, double, double, double, double, double, double, double, double, Vector2d), RayAabIntersection
  - intersectLineSegmentAab
```
public static int intersectLineSegmentAab(double p0X,
                                          double p0Y,
                                          double p0Z,
                                          double p1X,
                                          double p1Y,
                                          double p1Z,
                                          double minX,
                                          double minY,
                                          double minZ,
                                          double maxX,
                                          double maxY,
                                          double maxZ,
                                          Vector2d 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(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d)
  - intersectLineSegmentAab
```
public static int intersectLineSegmentAab(Vector3dc p0,
                                          Vector3dc p1,
                                          Vector3dc min,
                                          Vector3dc max,
                                          Vector2d 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(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector2d)
  - testRayAab
```
public static boolean testRayAab(double originX,
                                 double originY,
                                 double originZ,
                                 double dirX,
                                 double dirY,
                                 double dirZ,
                                 double minX,
                                 double minY,
                                 double minZ,
                                 double maxX,
                                 double maxY,
                                 double 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(Vector3dc, Vector3dc, Vector3dc, Vector3dc), RayAabIntersection
  - testRayAab
```
public static boolean testRayAab(Vector3dc origin,
                                 Vector3dc dir,
                                 Vector3dc min,
                                 Vector3dc 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(double, double, double, double, double, double, double, double, double, double, double, double), RayAabIntersection
  - testRayTriangleFront
```
public static boolean testRayTriangleFront(double originX,
                                           double originY,
                                           double originZ,
                                           double dirX,
                                           double dirY,
                                           double dirZ,
                                           double v0X,
                                           double v0Y,
                                           double v0Z,
                                           double v1X,
                                           double v1Y,
                                           double v1Z,
                                           double v2X,
                                           double v2Y,
                                           double v2Z,
                                           double 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(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3dc, double)
  - testRayTriangleFront
```
public static boolean testRayTriangleFront(Vector3dc origin,
                                           Vector3dc dir,
                                           Vector3dc v0,
                                           Vector3dc v1,
                                           Vector3dc v2,
                                           double 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(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)
  - testRayTriangle
```
public static boolean testRayTriangle(double originX,
                                      double originY,
                                      double originZ,
                                      double dirX,
                                      double dirY,
                                      double dirZ,
                                      double v0X,
                                      double v0Y,
                                      double v0Z,
                                      double v1X,
                                      double v1Y,
                                      double v1Z,
                                      double v2X,
                                      double v2Y,
                                      double v2Z,
                                      double 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(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3dc, double)
  - testRayTriangle
```
public static boolean testRayTriangle(Vector3dc origin,
                                      Vector3dc dir,
                                      Vector3dc v0,
                                      Vector3dc v1,
                                      Vector3dc v2,
                                      double 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(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)
  - intersectRayTriangleFront
```
public static double intersectRayTriangleFront(double originX,
                                               double originY,
                                               double originZ,
                                               double dirX,
                                               double dirY,
                                               double dirZ,
                                               double v0X,
                                               double v0Y,
                                               double v0Z,
                                               double v1X,
                                               double v1Y,
                                               double v1Z,
                                               double v2X,
                                               double v2Y,
                                               double v2Z,
                                               double 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(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3dc, double)
  - intersectRayTriangleFront
```
public static double intersectRayTriangleFront(Vector3dc origin,
                                               Vector3dc dir,
                                               Vector3dc v0,
                                               Vector3dc v1,
                                               Vector3dc v2,
                                               double 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(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)
  - intersectRayTriangle
```
public static double intersectRayTriangle(double originX,
                                          double originY,
                                          double originZ,
                                          double dirX,
                                          double dirY,
                                          double dirZ,
                                          double v0X,
                                          double v0Y,
                                          double v0Z,
                                          double v1X,
                                          double v1Y,
                                          double v1Z,
                                          double v2X,
                                          double v2Y,
                                          double v2Z,
                                          double 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(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3dc, double)
  - intersectRayTriangle
```
public static double intersectRayTriangle(Vector3dc origin,
                                          Vector3dc dir,
                                          Vector3dc v0,
                                          Vector3dc v1,
                                          Vector3dc v2,
                                          double 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(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)
  - testLineSegmentTriangle
```
public static boolean testLineSegmentTriangle(double p0X,
                                              double p0Y,
                                              double p0Z,
                                              double p1X,
                                              double p1Y,
                                              double p1Z,
                                              double v0X,
                                              double v0Y,
                                              double v0Z,
                                              double v1X,
                                              double v1Y,
                                              double v1Z,
                                              double v2X,
                                              double v2Y,
                                              double v2Z,
                                              double 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(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3dc, double)
  - testLineSegmentTriangle
```
public static boolean testLineSegmentTriangle(Vector3dc p0,
                                              Vector3dc p1,
                                              Vector3dc v0,
                                              Vector3dc v1,
                                              Vector3dc v2,
                                              double 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(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)
  - intersectLineSegmentTriangle
```
public static boolean intersectLineSegmentTriangle(double p0X,
                                                   double p0Y,
                                                   double p0Z,
                                                   double p1X,
                                                   double p1Y,
                                                   double p1Z,
                                                   double v0X,
                                                   double v0Y,
                                                   double v0Z,
                                                   double v1X,
                                                   double v1Y,
                                                   double v1Z,
                                                   double v2X,
                                                   double v2Y,
                                                   double v2Z,
                                                   double epsilon,
                                                   Vector3d 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(Vector3dc, Vector3dc, Vector3dc, Vector3dc, Vector3dc, double, Vector3d)
  - intersectLineSegmentTriangle
```
public static boolean intersectLineSegmentTriangle(Vector3dc p0,
                                                   Vector3dc p1,
                                                   Vector3dc v0,
                                                   Vector3dc v1,
                                                   Vector3dc v2,
                                                   double epsilon,
                                                   Vector3d 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(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, Vector3d)
  - intersectLineSegmentPlane
```
public static boolean intersectLineSegmentPlane(double p0X,
                                                double p0Y,
                                                double p0Z,
                                                double p1X,
                                                double p1Y,
                                                double p1Z,
                                                double a,
                                                double b,
                                                double c,
                                                double d,
                                                Vector3d 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(double a,
                                     double b,
                                     double c,
                                     double centerX,
                                     double centerY,
                                     double 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(double a,
                                          double b,
                                          double c,
                                          double centerX,
                                          double centerY,
                                          double radius,
                                          Vector3d 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(double x0,
                                          double y0,
                                          double x1,
                                          double y1,
                                          double centerX,
                                          double centerY,
                                          double radius,
                                          Vector3d 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(double minX,
                                  double minY,
                                  double maxX,
                                  double maxY,
                                  double a,
                                  double b,
                                  double 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(Vector2dc min,
                                  Vector2dc max,
                                  double a,
                                  double b,
                                  double 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(double minX,
                                  double minY,
                                  double maxX,
                                  double maxY,
                                  double x0,
                                  double y0,
                                  double x1,
                                  double 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(double minXA,
                                 double minYA,
                                 double maxXA,
                                 double maxYA,
                                 double minXB,
                                 double minYB,
                                 double maxXB,
                                 double 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(Vector2dc minA,
                                 Vector2dc maxA,
                                 Vector2dc minB,
                                 Vector2dc 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(double aX,
                                             double aY,
                                             double maX,
                                             double maY,
                                             double aR,
                                             double bX,
                                             double bY,
                                             double 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(Vector2d centerA,
                                             Vector2d moveA,
                                             double aR,
                                             Vector2d centerB,
                                             double 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(double aX,
                                            double aY,
                                            double radiusSquaredA,
                                            double bX,
                                            double bY,
                                            double radiusSquaredB,
                                            Vector3d 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(Vector2dc centerA,
                                            double radiusSquaredA,
                                            Vector2dc centerB,
                                            double radiusSquaredB,
                                            Vector3d 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(double aX,
                                       double aY,
                                       double rA,
                                       double bX,
                                       double bY,
                                       double 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(Vector2dc centerA,
                                       double radiusSquaredA,
                                       Vector2dc centerB,
                                       double 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 double distancePointLine(double pointX,
                                       double pointY,
                                       double a,
                                       double b,
                                       double 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 double distancePointLine(double pointX,
                                       double pointY,
                                       double x0,
                                       double y0,
                                       double x1,
                                       double 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 double distancePointLine(double pX,
                                       double pY,
                                       double pZ,
                                       double x0,
                                       double y0,
                                       double z0,
                                       double x1,
                                       double y1,
                                       double 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 double intersectRayLine(double originX,
                                      double originY,
                                      double dirX,
                                      double dirY,
                                      double pointX,
                                      double pointY,
                                      double normalX,
                                      double normalY,
                                      double 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 double intersectRayLine(Vector2dc origin,
                                      Vector2dc dir,
                                      Vector2dc point,
                                      Vector2dc normal,
                                      double 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 double intersectRayLineSegment(double originX,
                                             double originY,
                                             double dirX,
                                             double dirY,
                                             double aX,
                                             double aY,
                                             double bX,
                                             double 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(Vector2dc, Vector2dc, Vector2dc, Vector2dc)
  - intersectRayLineSegment
```
public static double intersectRayLineSegment(Vector2dc origin,
                                             Vector2dc dir,
                                             Vector2dc a,
                                             Vector2dc 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(double, double, double, double, double, double, double, double)
  - testAarCircle
```
public static boolean testAarCircle(double minX,
                                    double minY,
                                    double maxX,
                                    double maxY,
                                    double centerX,
                                    double centerY,
                                    double 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(Vector2dc min,
                                    Vector2dc max,
                                    Vector2dc center,
                                    double 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(double v0X,
                                             double v0Y,
                                             double v1X,
                                             double v1Y,
                                             double v2X,
                                             double v2Y,
                                             double pX,
                                             double pY,
                                             Vector2d 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(Vector2dc v0,
                                             Vector2dc v1,
                                             Vector2dc v2,
                                             Vector2dc p,
                                             Vector2d 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(double originX,
                                         double originY,
                                         double dirX,
                                         double dirY,
                                         double centerX,
                                         double centerY,
                                         double radiusSquared,
                                         Vector2d 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(Vector2dc origin,
                                         Vector2dc dir,
                                         Vector2dc center,
                                         double radiusSquared,
                                         Vector2d 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(double originX,
                                    double originY,
                                    double dirX,
                                    double dirY,
                                    double centerX,
                                    double centerY,
                                    double 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(Vector2dc origin,
                                    Vector2dc dir,
                                    Vector2dc center,
                                    double 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(double originX,
                                  double originY,
                                  double dirX,
                                  double dirY,
                                  double minX,
                                  double minY,
                                  double maxX,
                                  double maxY,
                                  Vector2d 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(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)
  - intersectRayAar
```
public static int intersectRayAar(Vector2dc origin,
                                  Vector2dc dir,
                                  Vector2dc min,
                                  Vector2dc max,
                                  Vector2d 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(double, double, double, double, double, double, double, double, Vector2d)
  - intersectLineSegmentAar
```
public static int intersectLineSegmentAar(double p0X,
                                          double p0Y,
                                          double p1X,
                                          double p1Y,
                                          double minX,
                                          double minY,
                                          double maxX,
                                          double maxY,
                                          Vector2d 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(Vector2dc, Vector2dc, Vector2dc, Vector2dc, Vector2d)
  - intersectLineSegmentAar
```
public static int intersectLineSegmentAar(Vector2dc p0,
                                          Vector2dc p1,
                                          Vector2dc min,
                                          Vector2dc max,
                                          Vector2d 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(double, double, double, double, double, double, double, double, Vector2d)
    
    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(double originX,
                                 double originY,
                                 double dirX,
                                 double dirY,
                                 double minX,
                                 double minY,
                                 double maxX,
                                 double 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(Vector2dc, Vector2dc, Vector2dc, Vector2dc)
  - testRayAar
```
public static boolean testRayAar(Vector2dc origin,
                                 Vector2dc dir,
                                 Vector2dc min,
                                 Vector2dc 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(double, double, double, double, double, double, double, double)
  - testPointTriangle
```
public static boolean testPointTriangle(double pX,
                                        double pY,
                                        double v0X,
                                        double v0Y,
                                        double v1X,
                                        double v1Y,
                                        double v2X,
                                        double 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(Vector2dc point,
                                        Vector2dc v0,
                                        Vector2dc v1,
                                        Vector2dc 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(double pX,
                                   double pY,
                                   double minX,
                                   double minY,
                                   double maxX,
                                   double 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(double pX,
                                      double pY,
                                      double centerX,
                                      double centerY,
                                      double 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(double centerX,
                                         double centerY,
                                         double radiusSquared,
                                         double v0X,
                                         double v0Y,
                                         double v1X,
                                         double v1Y,
                                         double v2X,
                                         double 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(Vector2dc center,
                                         double radiusSquared,
                                         Vector2dc v0,
                                         Vector2dc v1,
                                         Vector2dc 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(double[] verticesXY,
                                      double originX,
                                      double originY,
                                      double dirX,
                                      double dirY,
                                      Vector2d 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(Vector2dc[] vertices,
                                      double originX,
                                      double originY,
                                      double dirX,
                                      double dirY,
                                      Vector2d 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(double ps1x,
                                        double ps1y,
                                        double pe1x,
                                        double pe1y,
                                        double ps2x,
                                        double ps2y,
                                        double pe2x,
                                        double pe2y,
                                        Vector2d 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(Vector2d[] v1s,
                                         Vector2d[] v2s)
```
    Test if the two convex polygons, given via their vertices, intersect.
    
    Parameters:
    
    v1s - the vertices of the first convex polygon
    
    v2s - the vertices of the second convex polygon
    
    Returns:
    
    true if the convex polygons intersect; false otherwise

Class Intersectiond

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

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

POINT_ON_TRIANGLE_FACE

AAR_SIDE_MINX

AAR_SIDE_MINY

AAR_SIDE_MAXX

AAR_SIDE_MAXY

OUTSIDE

ONE_INTERSECTION

TWO_INTERSECTION

INSIDE

Constructor Detail

Intersectiond

Method Detail

testPlaneSphere

intersectPlaneSphere

intersectPlaneSweptSphere

testPlaneSweptSphere

testAabPlane

testAabPlane

testAabAab

testAabAab

testObOb

testObOb

intersectSphereSphere

intersectSphereSphere

intersectSphereTriangle

testSphereSphere

testSphereSphere

distancePointPlane

distancePointPlane

intersectRayPlane

intersectRayPlane

intersectRayPlane

testAabSphere

testAabSphere

findClosestPointOnPlane

findClosestPointOnLineSegment

findClosestPointsLineSegments

findClosestPointsLineSegmentTriangle

findClosestPointOnTriangle

findClosestPointOnTriangle

findClosestPointOnRectangle

intersectSweptSphereTriangle

testPointInTriangle

intersectRaySphere

intersectRaySphere

testRaySphere

testRaySphere

testLineSegmentSphere

testLineSegmentSphere

intersectRayAab

intersectRayAab

intersectLineSegmentAab

intersectLineSegmentAab

testRayAab

testRayAab

testRayTriangleFront

testRayTriangleFront

testRayTriangle

testRayTriangle

intersectRayTriangleFront

intersectRayTriangleFront

intersectRayTriangle

intersectRayTriangle

testLineSegmentTriangle

testLineSegmentTriangle

intersectLineSegmentTriangle

intersectLineSegmentTriangle

intersectLineSegmentPlane