CollisionDetection.h

Go to the documentation of this file.

#ifndef G3D_CollisionDetection_h
#define G3D_CollisionDetection_h

#include "G3D/platform.h"
#include "G3D/Vector3.h"
#include "G3D/Plane.h"
#include "G3D/Box.h"
#include "G3D/Triangle.h"
#include "G3D/Array.h"
#include "G3D/Ray.h"
#include "G3D/Line.h"

namespace G3D {


class CollisionDetection {
private:

 static Vector3 ignore;
 
 static bool ignoreBool;

 static Array<Vector3> ignoreArray;

 // Static class!
 CollisionDetection() {}
 virtual ~CollisionDetection() {}

public:

 static Vector3 separatingAxisForSolidBoxSolidBox(
 const int separatingAxisIndex,
 const Box & box1,
 const Box & box2);

 static bool parallelAxisForSolidBoxSolidBox(
 const double* ca,
 const double epsilon,
 int & axis1,
 int & axis2);

 static float projectedDistanceForSolidBoxSolidBox(
 const int separatingAxisIndex,
 const Vector3 & a,
 const Vector3 & b,
 const Vector3 & D,
 const double* c,
 const double* ca,
 const double* ad,
 const double* bd);


 static void fillSolidBoxSolidBoxInfo(
 const Box & box1,
 const Box & box2,
 Vector3 & a,
 Vector3 & b,
 Vector3 & D,
 double* c,
 double* ca,
 double* ad,
 double* bd);

 static bool conservativeBoxBoxTest(
 const Vector3 & a,
 const Vector3 & b,
 const Vector3 & D);

 static bool fixedSolidBoxIntersectsFixedSolidBox(
 const Box& box1,
 const Box& box2,
 const int lastSeparatingAxis = -1);

 static void closestPointsBetweenLineAndLine(
 const Line & line1,
 const Line & line2,
 Vector3 & closest1,
 Vector3 & closest2);

 static float penetrationDepthForFixedBoxFixedBox(
 const Box& box1,
 const Box& box2,
 Array<Vector3>& contactPoints,
 Array<Vector3>& contactNormals,
 const int lastSeparatingAxis = -1);

 static float penetrationDepthForFixedSphereFixedSphere(
 const class Sphere& sphereA,
 const Sphere& sphereB,
 Array<Vector3>& contactPoints,
 Array<Vector3>& contactNormals = ignoreArray);

 static float penetrationDepthForFixedSphereFixedBox(
 const Sphere& sphere,
 const Box& box,
 Array<Vector3>& contactPoints,
 Array<Vector3>& contactNormals = ignoreArray);

 static float penetrationDepthForFixedSphereFixedPlane(
 const Sphere& sphereA,
 const class Plane& planeB,
 Array<Vector3>& contactPoints,
 Array<Vector3>& contactNormals = ignoreArray);

 static float penetrationDepthForFixedBoxFixedPlane(
 const Box& box,
 const Plane& plane,
 Array<Vector3>& contactPoints,
 Array<Vector3>& contactNormals = ignoreArray);

 static float collisionTimeForMovingPointFixedPlane(
 const Vector3& point,
 const Vector3& velocity,
 const class Plane& plane,
 Vector3& outLocation,
 Vector3& outNormal = ignore);

 inline static float collisionTimeForMovingPointFixedTriangle(
 const Vector3& orig,
 const Vector3& dir,
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2) {
 return Ray::fromOriginAndDirection(orig, dir).intersectionTime(v0, v1, v2);
 }

 inline static float collisionTimeForMovingPointFixedTriangle(
 const Vector3& orig,
 const Vector3& dir,
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2,
 Vector3& location) {
 float t = collisionTimeForMovingPointFixedTriangle(orig, dir, v0, v1, v2);
 if (t < finf()) {
 location = orig + dir * t;
 }
 return t;
 }

 inline static float collisionTimeForMovingPointFixedTriangle(
 const Vector3& orig,
 const Vector3& dir,
 const Triangle& tri,
 Vector3& location = ignore,
 Vector3& normal = ignore) {

 float t = collisionTimeForMovingPointFixedTriangle(
 orig, dir, tri.vertex(0), tri.vertex(1), tri.vertex(2));
 
 if ((t < finf()) && (&location != &ignore)) {
 location = orig + dir * t;
 normal = tri.normal();
 }
 return t;
 }

 inline static float collisionTimeForMovingPointFixedTriangle(
 const Vector3& orig,
 const Vector3& dir,
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2,
 Vector3& location,
 Vector3& normal) {
 float t = collisionTimeForMovingPointFixedTriangle(orig, dir, v0, v1, v2);
 if (t < finf()) {
 location = orig + dir * t;
 normal = (v1 - v0).cross(v2 - v0).direction();
 }
 return t;
 }

 static float collisionTimeForMovingPointFixedAABox(
 const Vector3& point,
 const Vector3& velocity,
 const class AABox& box,
 Vector3& outLocation,
 bool& inside = ignoreBool,
 Vector3& outNormal = ignore);

 static bool collisionLocationForMovingPointFixedAABox(
 const Vector3& point,
 const Vector3& velocity,
 const class AABox& box,
 Vector3& outLocation,
 bool& inside = ignoreBool,
 Vector3& normal = ignore);


 static bool __fastcall rayAABox(
 const Ray& ray,
 const Vector3& invDir,
 const AABox& box,
 const Vector3& boxCenter,
 float boundingRadiusSquared,
 Vector3& location,
 bool& inside);

 static float collisionTimeForMovingPointFixedSphere(
 const Vector3& point,
 const Vector3& velocity,
 const class Sphere& sphere,
 Vector3& outLocation,
 Vector3& outNormal = ignore,
 bool solid = false);

 static float collisionTimeForMovingPointFixedBox(
 const Vector3& point,
 const Vector3& velocity,
 const class Box& box,
 Vector3& outLocation,
 Vector3& outNormal = ignore);

 static float collisionTimeForMovingPointFixedRectangle(
 const Vector3& point,
 const Vector3& velocity,
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2,
 const Vector3& v3,
 Vector3& outLocation,
 Vector3& outNormal = ignore);

 static float collisionTimeForMovingPointFixedCapsule(
 const Vector3& point,
 const Vector3& velocity,
 const class Capsule& capsule,
 Vector3& outLocation,
 Vector3& outNormal = ignore);

 static float collisionTimeForMovingSphereFixedPlane(
 const class Sphere& sphere,
 const Vector3& velocity,
 const class Plane& plane,
 Vector3& outLocation,
 Vector3& outNormal = ignore);

 static float collisionTimeForMovingSphereFixedTriangle(
 const class Sphere& sphere,
 const Vector3& velocity,
 const Triangle& triangle,
 Vector3& outLocation,
 float b[3] = (float*)&ignore);

 static float collisionTimeForMovingSphereFixedRectangle(
 const class Sphere& sphere,
 const Vector3& velocity,
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2,
 const Vector3& v3,
 Vector3& outLocation,
 Vector3& outNormal = ignore);

 static float collisionTimeForMovingSphereFixedBox(
 const class Sphere& sphere,
 const Vector3& velocity,
 const class Box& box,
 Vector3& outLocation,
 Vector3& outNormal = ignore);

 static float collisionTimeForMovingSphereFixedSphere(
 const Sphere& sphere,
 const Vector3& velocity,
 const Sphere& fixedSphere,
 Vector3& outLocation,
 Vector3& outNormal = ignore);

 static float collisionTimeForMovingSphereFixedCapsule(
 const class Sphere& sphere,
 const Vector3& velocity,
 const class Capsule& capsule,
 Vector3& outLocation,
 Vector3& outNormal = ignore);

 static Vector3 bounceDirection(
 const class Sphere& sphere,
 const Vector3& velocity,
 const float collisionTime,
 const Vector3& collisionLocation,
 const Vector3& collisionNormal);

 static Vector3 slideDirection(
 const class Sphere& sphere,
 const Vector3& velocity,
 const float collisionTime,
 const Vector3& collisionLocation);

 static Vector3 closestPointOnLineSegment(
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& point);

 static Vector3 closestPointOnLineSegment(
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& edgeDirection,
 float edgeLength,
 const Vector3& point);

 static Vector3 closestPointOnTrianglePerimeter(
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2,
 const Vector3& point);

 static Vector3 closestPointOnTrianglePerimeter(
 const Vector3 v[3],
 const Vector3 edgeDirection[3],
 const float edgeLength[3],
 const Vector3& point,
 int& edgeIndex);

 static bool isPointInsideTriangle(
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2,
 const Vector3& normal,
 const Vector3& point,
 float b[3],
 Vector3::Axis primaryAxis = Vector3::DETECT_AXIS);

 inline static bool isPointInsideTriangle(
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2,
 const Vector3& normal,
 const Vector3& point,
 Vector3::Axis primaryAxis = Vector3::DETECT_AXIS) {

 float b[3];
 return isPointInsideTriangle(v0, v1, v2, normal, point, b, primaryAxis);
 }

 static bool movingSpherePassesThroughFixedBox(
 const Sphere& sphere,
 const Vector3& velocity,
 const Box& box,
 double timeLimit = inf());

 static bool movingSpherePassesThroughFixedSphere(
 const Sphere& sphere,
 const Vector3& velocity,
 const Sphere& fixedSphere,
 double timeLimit = inf());

 static bool fixedSolidSphereIntersectsFixedSolidSphere(
 const Sphere& sphere1,
 const Sphere& sphere2);

 static bool fixedSolidSphereIntersectsFixedSolidBox(
 const Sphere& sphere,
 const Box& box);

 static bool fixedSolidSphereIntersectsFixedTriangle(
 const Sphere& sphere,
 const Triangle& triangle);

 static bool fixedSolidBoxIntersectsFixedTriangle(
 const AABox& box, 
 const Triangle& triangle);

 static bool isPointInsideRectangle(
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2,
 const Vector3& v3,
 const Vector3& normal,
 const Vector3& point);

 static Vector3 closestPointToRectanglePerimeter(
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2,
 const Vector3& v3,
 const Vector3& point);

 static Vector3 closestPointToRectangle(
 const Vector3& v0,
 const Vector3& v1,
 const Vector3& v2,
 const Vector3& v3,
 const Vector3& point);
};

} // namespace

#endif // G3D_COLLISIONDETECTION_H