# Fastest 3D collision detection between two oriented bounding boxes (OBBs)

I am at the point in my game where I need to add a collision system. I tried jBullet, and while it did work, it wasn't what I was looking for. I just want a simple way to test if two oriented bounding box (OBB) trees are colliding.

I was going to do collision by using the tree. Make an AABB for broadphase, then if that passes test if each OBB in tree collide with the other tree.

I did find a few things on the internet, but I couldn't understand them completely. What I am asking for is a website or resource that explains 3D OBB collisions well?

I learned that GJK is faster than SAT, and it appears to be able to tell me how far the boxes penetrate each other. I found some GJK stuff, but they were not boxes; instead, more complex and confusing things.

I just want to be able to make an OBB from 3 vectors: center, size, and rotation of each axis. Then be able to test collisions with those. Thank you in advance for anything you post.

• You sure you need bounding boxes? If you have a tree of bones, and you have the centers and a rough idea of the volume of each bone, bounding spheres are easier and a lot faster to implement. Commented Sep 20, 2015 at 20:26
• Have you checked the answer on a similar question in StackOverflow from HaAlef? Commented May 1, 2023 at 12:54

You mentioned using GJK, but that you stepped away from it because they were using things that are more complicated than boxes. Might I suggest that you stepped away too soon? Because GJK uses support maps, you can use GJK for any convex shape, including OBBs, for which a support mapping is defined. So, if you know how to define the support function for an OBB, you can use GJK without worry.

Not only can this help you for OBBs, but it will also be easy to expand the system to work with any two convex shapes for future projects, or if this project develops to require it.

## Calculating a Support for an OBB

Given an input direction $$\d\$$ (converted to the OBB's local space), one way to calculate a support for an OBB would be to define a ray from the center of the OBB in the direction $$\d\$$. The support mapping could simply calculate which face the ray intersects and return any point on that face.

Another, simpler (but likely slightly more expensive) method would be to just take the dot product of $$\d\$$ (converted to the OBB's local space) with each of the eight corners of the OBB, and return the corner that yielded the largest dot product.

(Note that this method actually works for any convex shape that you define as a discrete collection of vertices. Something like a sphere or a capsule would require special operations to handle the smooth, curved surfaces.)

Vector3f d = /*OBB space direction*/;
Vector3f[] corners = /*The corners of the OBB in OBB space*/;

float maxDot = Float.NEGATIVE_INFINITY;
int maxDotIndex = -1;

for(int i = 0; i < corners.length; i++) {
dot = Vector3f.dot(corners[i], d);
if(dot > maxDot) {
maxDot = dot;
maxDotIndex = i;
}
}

return globalPositionOf(corners[maxIndex]);


From there, it's just vanilla GJK. Since we've defined a support function for an OBB, you can just learn GJK from the articles you were reading without having to worry about the complicated shapes at all. Some additional articles on GJK that helped me when I was learning it are here and here, and a working implementation of GJK can be found here.

I saw the link in your comment that showed the character with the OBBs that were arraigned around the mesh. Sometimes that can be done with bounding spheres and then there is no orientation issues and a sphere test is usually faster.

Your character, if showing the bounding structures like in your link would look more like the Michelin man.

Here is an actual working example of an AABB, which is directly from my game engine:

using System;
using OpenTK;
using OpenTK.Graphics.OpenGL;

namespace GrimoireEngine.Framework.Maths
{
public struct BoundingBox : IEquatable<BoundingBox>
{
public Vector3 Min;
public Vector3 Max;

public const int CornerCount = 8;

public static Vector3 MaxVector3
{
get
{
return new Vector3(float.MaxValue);
}
}

public static Vector3 MinVector3
{
get
{
return new Vector3(float.MinValue);
}
}

public static BoundingBox Identity
{
get
{
return new BoundingBox(Vector3.Zero, Vector3.One);
}
}

public static BoundingBox Zero
{
get
{
return new BoundingBox();
}
}

public BoundingBox(Vector3 min, Vector3 max)
{
Min = min;
Max = max;
}

public BoundingBox(
float minX, float minY, float minZ,
float maxX, float maxY, float maxZ)
: this(
new Vector3(minX, minY, minZ),
new Vector3(maxX, maxY, maxZ))
{ }

public bool Collides(BoundingBox box)
{
if (box.Max.X < Min.X
|| box.Min.X > Max.X
|| box.Max.Y < Min.Y
|| box.Min.Y > Max.Y
|| box.Max.Z < Min.Z
|| box.Min.Z > Max.Z)
{
return false;
}
if (box.Min.X >= Min.X
&& box.Max.X <= Max.X
&& box.Min.Y >= Min.Y
&& box.Max.Y <= Max.Y
&& box.Min.Z >= Min.Z
&& box.Max.Z <= Max.Z)
{
return true;
}
return true;
}

public ContainmentType Contains(BoundingBox box)
{
if (box.Max.X < Min.X
|| box.Min.X > Max.X
|| box.Max.Y < Min.Y
|| box.Min.Y > Max.Y
|| box.Max.Z < Min.Z
|| box.Min.Z > Max.Z)
{
return ContainmentType.Disjoint;
}
if (box.Min.X >= Min.X
&& box.Max.X <= Max.X
&& box.Min.Y >= Min.Y
&& box.Max.Y <= Max.Y
&& box.Min.Z >= Min.Z
&& box.Max.Z <= Max.Z)
{
return ContainmentType.Contains;
}
return ContainmentType.Intersects;
}

public bool Collides(BoundingFrustum frustum)
{
int i;
bool contained;
Vector3[] corners = frustum.GetCorners();
for (i = 0; i < corners.Length; i++)
{
if (corners[i].X < Min.X
|| corners[i].X > Max.X
|| corners[i].Y < Min.Y
|| corners[i].Y > Max.Y
|| corners[i].Z < Min.Z
|| corners[i].Z > Max.Z)
{
contained = false;
}
else if (corners[i].X == Min.X
|| corners[i].X == Max.X
|| corners[i].Y == Min.Y
|| corners[i].Y == Max.Y
|| corners[i].Z == Min.Z
|| corners[i].Z == Max.Z)
{
contained = true;
}
else
{
contained = true;
}
if (contained == false)
{
break;
}
}
if (i == corners.Length)
{
return true;
}
if (i != 0)
{
return true;
}
i++;
for (; i < corners.Length; i++)
{
if (corners[i].X < Min.X
|| corners[i].X > Max.X
|| corners[i].Y < Min.Y
|| corners[i].Y > Max.Y
|| corners[i].Z < Min.Z
|| corners[i].Z > Max.Z)
{
contained = false;
}
else if (corners[i].X == Min.X
|| corners[i].X == Max.X
|| corners[i].Y == Min.Y
|| corners[i].Y == Max.Y
|| corners[i].Z == Min.Z
|| corners[i].Z == Max.Z)
{
contained = true;
}
else
{
contained = true;
}
if (contained != true)
{
return true;
}
}
return true;
}

public ContainmentType Contains(BoundingFrustum frustum)
{
int i;
ContainmentType contained;
Vector3[] corners = frustum.GetCorners();
for (i = 0; i < corners.Length; i++)
{
if (corners[i].X < Min.X
|| corners[i].X > Max.X
|| corners[i].Y < Min.Y
|| corners[i].Y > Max.Y
|| corners[i].Z < Min.Z
|| corners[i].Z > Max.Z)
{
contained = ContainmentType.Disjoint;
}
else if (corners[i].X == Min.X
|| corners[i].X == Max.X
|| corners[i].Y == Min.Y
|| corners[i].Y == Max.Y
|| corners[i].Z == Min.Z
|| corners[i].Z == Max.Z)
{
contained = ContainmentType.Intersects;
}
else
{
contained = ContainmentType.Contains;
}
if (contained == ContainmentType.Disjoint)
{
break;
}
}
if (i == corners.Length)
{
return ContainmentType.Contains;
}
if (i != 0)
{
return ContainmentType.Intersects;
}
i++;
for (; i < corners.Length; i++)
{
if (corners[i].X < Min.X
|| corners[i].X > Max.X
|| corners[i].Y < Min.Y
|| corners[i].Y > Max.Y
|| corners[i].Z < Min.Z
|| corners[i].Z > Max.Z)
{
contained = ContainmentType.Disjoint;
}
else if (corners[i].X == Min.X
|| corners[i].X == Max.X
|| corners[i].Y == Min.Y
|| corners[i].Y == Max.Y
|| corners[i].Z == Min.Z
|| corners[i].Z == Max.Z)
{
contained = ContainmentType.Intersects;
}
else
{
contained = ContainmentType.Contains;
}
if (contained != ContainmentType.Contains)
{
return ContainmentType.Intersects;
}
}
return ContainmentType.Contains;
}

public bool Collides(BoundingSphere sphere)
{
if (sphere.Center.X - Min.X >= sphere.Radius
&& sphere.Center.Y - Min.Y >= sphere.Radius
&& sphere.Center.Z - Min.Z >= sphere.Radius
&& Max.X - sphere.Center.X >= sphere.Radius
&& Max.Y - sphere.Center.Y >= sphere.Radius
&& Max.Z - sphere.Center.Z >= sphere.Radius)
{
return true;
}
double dmin = 0;
double e = sphere.Center.X - Min.X;
if (e < 0)
{
{
return false;
}
dmin += e * e;
}
else
{
e = sphere.Center.X - Max.X;
if (e > 0)
{
{
return false;
}
dmin += e * e;
}
}
e = sphere.Center.Y - Min.Y;
if (e < 0)
{
{
return false;
}
dmin += e * e;
}
else
{
e = sphere.Center.Y - Max.Y;
if (e > 0)
{
{
return false;
}
dmin += e * e;
}
}
e = sphere.Center.Z - Min.Z;
if (e < 0)
{
{
return false;
}
dmin += e * e;
}
else
{
e = sphere.Center.Z - Max.Z;
if (e > 0)
{
{
return false;
}
dmin += e * e;
}
}
}

public ContainmentType Contains(BoundingSphere sphere)
{
if (sphere.Center.X - Min.X >= sphere.Radius
&& sphere.Center.Y - Min.Y >= sphere.Radius
&& sphere.Center.Z - Min.Z >= sphere.Radius
&& Max.X - sphere.Center.X >= sphere.Radius
&& Max.Y - sphere.Center.Y >= sphere.Radius
&& Max.Z - sphere.Center.Z >= sphere.Radius)
{
return ContainmentType.Contains;
}
double dmin = 0;
double e = sphere.Center.X - Min.X;
if (e < 0)
{
{
return ContainmentType.Disjoint;
}
dmin += e * e;
}
else
{
e = sphere.Center.X - Max.X;
if (e > 0)
{
{
return ContainmentType.Disjoint;
}
dmin += e * e;
}
}
e = sphere.Center.Y - Min.Y;
if (e < 0)
{
{
return ContainmentType.Disjoint;
}
dmin += e * e;
}
else
{
e = sphere.Center.Y - Max.Y;
if (e > 0)
{
{
return ContainmentType.Disjoint;
}
dmin += e * e;
}
}
e = sphere.Center.Z - Min.Z;
if (e < 0)
{
{
return ContainmentType.Disjoint;
}
dmin += e * e;
}
else
{
e = sphere.Center.Z - Max.Z;
if (e > 0)
{
{
return ContainmentType.Disjoint;
}
dmin += e * e;
}
}
}

public bool Collides(Vector3 point)
{
if (point.X < Min.X
|| point.X > Max.X
|| point.Y < Min.Y
|| point.Y > Max.Y
|| point.Z < Min.Z
|| point.Z > Max.Z)
{
return false;
}
if (point.X == Min.X
|| point.X == Max.X
|| point.Y == Min.Y
|| point.Y == Max.Y
|| point.Z == Min.Z
|| point.Z == Max.Z)
{
return true;
}
return true;
}

public ContainmentType Contains(Vector3 point)
{
ContainmentType result;
if (point.X < Min.X
|| point.X > Max.X
|| point.Y < Min.Y
|| point.Y > Max.Y
|| point.Z < Min.Z
|| point.Z > Max.Z)
{
result = ContainmentType.Disjoint;
}
else if (point.X == Min.X
|| point.X == Max.X
|| point.Y == Min.Y
|| point.Y == Max.Y
|| point.Z == Min.Z
|| point.Z == Max.Z)
{
result = ContainmentType.Intersects;
}
else
{
result = ContainmentType.Contains;
}
return result;
}

public bool Equals(BoundingBox other)
{
return (Min == other.Min) && (Max == other.Max);
}

public override bool Equals(object obj)
{
return (obj is BoundingBox) && Equals((BoundingBox)obj);
}

public Vector3[] GetCorners()
{
return new[] {
new Vector3(Min.X, Max.Y, Max.Z),
new Vector3(Max.X, Max.Y, Max.Z),
new Vector3(Max.X, Min.Y, Max.Z),
new Vector3(Min.X, Min.Y, Max.Z),
new Vector3(Min.X, Max.Y, Min.Z),
new Vector3(Max.X, Max.Y, Min.Z),
new Vector3(Max.X, Min.Y, Min.Z),
new Vector3(Min.X, Min.Y, Min.Z)
};
}

public override int GetHashCode()
{
return Min.GetHashCode() + Max.GetHashCode();
}

public bool Intersects(BoundingBox box)
{
if ((Max.X >= box.Min.X) && (Min.X <= box.Max.X))
{
if ((Max.Y < box.Min.Y) || (Min.Y > box.Max.Y))
{
return false;
}
return (Max.Z >= box.Min.Z) && (Min.Z <= box.Max.Z);
}
return false;
}

public bool Intersects(BoundingFrustum frustum)
{
return frustum.Intersects(this);
}

public bool Intersects(BoundingSphere sphere)
{
if (sphere.Center.X - Min.X > sphere.Radius
&& sphere.Center.Y - Min.Y > sphere.Radius
&& sphere.Center.Z - Min.Z > sphere.Radius
&& Max.X - sphere.Center.X > sphere.Radius
&& Max.Y - sphere.Center.Y > sphere.Radius
&& Max.Z - sphere.Center.Z > sphere.Radius)
{
return true;
}
double dmin = 0;
if (sphere.Center.X - Min.X <= sphere.Radius)
{
dmin += (sphere.Center.X - Min.X) * (sphere.Center.X - Min.X);
}
else if (Max.X - sphere.Center.X <= sphere.Radius)
{
dmin += (sphere.Center.X - Max.X) * (sphere.Center.X - Max.X);
}
if (sphere.Center.Y - Min.Y <= sphere.Radius)
{
dmin += (sphere.Center.Y - Min.Y) * (sphere.Center.Y - Min.Y);
}
else if (Max.Y - sphere.Center.Y <= sphere.Radius)
{
dmin += (sphere.Center.Y - Max.Y) * (sphere.Center.Y - Max.Y);
}
if (sphere.Center.Z - Min.Z <= sphere.Radius)
{
dmin += (sphere.Center.Z - Min.Z) * (sphere.Center.Z - Min.Z);
}
else if (Max.Z - sphere.Center.Z <= sphere.Radius)
{
dmin += (sphere.Center.Z - Max.Z) * (sphere.Center.Z - Max.Z);
}
}

public PlaneIntersectionType Intersects(Plane plane)
{
Vector3 positiveVertex;
Vector3 negativeVertex;
if (plane.Normal.X >= 0)
{
positiveVertex.X = Max.X;
negativeVertex.X = Min.X;
}
else
{
positiveVertex.X = Min.X;
negativeVertex.X = Max.X;
}
if (plane.Normal.Y >= 0)
{
positiveVertex.Y = Max.Y;
negativeVertex.Y = Min.Y;
}
else
{
positiveVertex.Y = Min.Y;
negativeVertex.Y = Max.Y;
}
if (plane.Normal.Z >= 0)
{
positiveVertex.Z = Max.Z;
negativeVertex.Z = Min.Z;
}
else
{
positiveVertex.Z = Min.Z;
negativeVertex.Z = Max.Z;
}
float distance = plane.Normal.X * negativeVertex.X + plane.Normal.Y * negativeVertex.Y + plane.Normal.Z * negativeVertex.Z + plane.D;
if (distance > 0)
{
return PlaneIntersectionType.Front;
}
distance = plane.Normal.X * positiveVertex.X + plane.Normal.Y * positiveVertex.Y + plane.Normal.Z * positiveVertex.Z + plane.D;
if (distance < 0)
{
return PlaneIntersectionType.Back;
}
return PlaneIntersectionType.Intersecting;
}

public float? Intersects(Ray ray)
{
return ray.Intersects(this);
}

public static bool operator ==(BoundingBox a, BoundingBox b)
{
return a.Equals(b);
}

public static bool operator !=(BoundingBox a, BoundingBox b)
{
return !a.Equals(b);
}

public override string ToString()
{
return "{{Min:" + Min + " Max:" + Max + "}}";
}

public void DrawImmediate()
{
GL.Begin(PrimitiveType.LineLoop);
GL.Vertex3(Max.X, Max.Y, Min.Z);
GL.Vertex3(Min.X, Max.Y, Min.Z);
GL.Vertex3(Min.X, Min.Y, Min.Z);
GL.Vertex3(Max.X, Min.Y, Min.Z);
GL.End();
GL.Begin(PrimitiveType.LineLoop);
GL.Vertex3(Max.X, Min.Y, Max.Z);
GL.Vertex3(Max.X, Max.Y, Max.Z);
GL.Vertex3(Min.X, Max.Y, Max.Z);
GL.Vertex3(Min.X, Min.Y, Max.Z);
GL.End();
GL.Begin(PrimitiveType.LineLoop);
GL.Vertex3(Max.X, Max.Y, Min.Z);
GL.Vertex3(Max.X, Max.Y, Max.Z);
GL.Vertex3(Min.X, Max.Y, Max.Z);
GL.Vertex3(Min.X, Max.Y, Min.Z);
GL.End();
GL.Begin(PrimitiveType.LineLoop);
GL.Vertex3(Max.X, Min.Y, Max.Z);
GL.Vertex3(Min.X, Min.Y, Max.Z);
GL.Vertex3(Min.X, Min.Y, Min.Z);
GL.Vertex3(Max.X, Min.Y, Min.Z);
GL.End();
}
}
}


Just remove the other Bounding type methods.

• This doesn't look like an OOB to me, but an AABB, which doesn't seem to be what OP was looking for?
– user35344
Commented Dec 22, 2016 at 22:11
• @Tyyppi_77 The question title reads "Fastest Bounding Box Algorithm". This is the problem with ambiguous questions. Commented Dec 22, 2016 at 22:12
• The question body seems to indicate quite clearly that OP is asking about OOBs: "I just want to be able to make an OBB".
– user35344
Commented Dec 22, 2016 at 22:15

Molly Rocket is forever your friend.

http://mollyrocket.com/849

But it sounds like you are misunderstanding the general use of a bounding box. You don't really use it for a physics collision system. Especially when it can be terribly inefficient for that sort of use.

Perhaps you are thinking of a Scene Graph's collision query? Where you check if an object is entering a QuadTree, or an Octree, and you quickly rebuild your graph.

• Sorry if I was misunderstood. The way I was thinking of doing collision was by having each bone on the mesh have a bounding box, which would each move along with the bone's matrix. For example: link. It seems to be faster than having to do trimesh collision, especially if the mesh is going to have skeletal animation. I was not going to have complex physics, just simple collision callbacks to notify of a collision between meshes. Commented Sep 20, 2015 at 4:50
• Your answer relies heavily on an external link. I suggest you update the answer to include the relevant information here in case the link goes down some day. Commented Sep 20, 2015 at 6:24
• Oh. A hit box is what you wanted. Hit boxes aren't necessarily trees, and not really AABs either. They are basically invisible collision meshes attached to the bones. The physics library that you used previously can easily help you do this as well. But yeah, GTK still can work fairly well in this sort of system. Especially if you want to know what did what. Commented Sep 20, 2015 at 7:49