DEV Community: Pratyush Mohanty

The Math Behind Bounding Box Collision Detection - AABB vs OBB(Separate Axis Theorem)

Pratyush Mohanty — Sun, 31 Aug 2025 08:15:15 +0000

Collision detection is one of the most important building blocks in computer graphics, physics simulations, and game development. A common and powerful way to handle collision between complex shapes is to use bounding volumes, and among them, the bounding box provides a good balance between simplicity and efficiency.

In this article, we will first look at Axis-Aligned Bounding Boxes (AABB), then move on to Oriented Bounding Boxes (OBB), and finally show how the Separating Axis Theorem (SAT) allows us to detect collisions in 2D and 3D.

Axis-Aligned Bounding Box (AABB)

An Axis-Aligned Bounding Box (AABB) is the simplest bounding volume. It is a box aligned with the coordinate axes, which makes it very easy to compute but less flexible when objects rotate.

Checking whether an AABB intersects another AABB is similar to testing whether a point lies inside a box. The difference is that we must perform one test per axis, using the boundaries of both boxes.

For example, along the X-axis, we simply ask whether the intervals $A_{minX}, A_{maxX}]$ and $B_{minX}, B_{maxX}]$ overlap. If they do not overlap on any axis, the boxes are separated and thus not colliding.

Mathematical formula:

(A_{minX} \leq B_{maxX} \wedge A_{maxX} \geq B_{minX}) \ \wedge (A_{minY} \leq B_{maxY} \wedge A_{maxY} \geq B_{minY}) \ \wedge (A_{minZ} \leq B_{maxZ} \wedge A_{maxZ} \geq B_{minZ})

This means the ranges must overlap along all three axes for the AABBs to collide.

In JavaScript, the check might look like this:

function intersectAABB(a, b) {
  return (a.minX <= b.maxX && a.maxX >= b.minX) &&
         (a.minY <= b.maxY && a.maxY >= b.minY) &&
         (a.minZ <= b.maxZ && a.maxZ >= b.minZ);
}

In C#, an equivalent implementation would be:

public struct AABB
{
    public float MinX, MinY, MinZ;
    public float MaxX, MaxY, MaxZ;

    public AABB(float minX, float minY, float minZ, float maxX, float maxY, float maxZ)
    {
        MinX = minX; MinY = minY; MinZ = minZ;
        MaxX = maxX; MaxY = maxY; MaxZ = maxZ;
    }
}

public static class Collision
{
    public static bool IntersectAABB(AABB a, AABB b)
    {
        return (a.MinX <= b.MaxX && a.MaxX >= b.MinX) &&
               (a.MinY <= b.MaxY && a.MaxY >= b.MinY) &&
               (a.MinZ <= b.MaxZ && a.MaxZ >= b.MinZ);
    }
}

This simple check is widely used in real-time applications because of its efficiency.

Oriented Bounding Box (OBB)

An Oriented Bounding Box (OBB) is a bounding box that can rotate with the object it encloses. It is defined by a center point, local axes, and half-extents. Because it can rotate, it fits shapes more tightly than an AABB. However, this makes collision detection more complex.

To check for collisions between OBBs, we use the Separating Axis Theorem (SAT).

The Separating Axis Theorem (SAT)

The SAT states:

Two convex shapes do not collide if and only if there exists an axis along which their projections do not overlap.

This means if we can find even a single separating axis, then the OBBs are not colliding. If no separating axis exists, then the OBBs must intersect.

Applying SAT in 2D (Rectangle vs. Rectangle)

For 2D OBBs (rectangles), possible separating axes are the edges of both rectangles. Since each rectangle has two unique directions, we only need to test four axes.

Steps:

Take the two edge directions of rectangle A and rectangle B.
Use them as candidate separating axes.
Project both rectangles onto each axis.
If projections fail to overlap on any axis, the rectangles do not collide.
If projections overlap on all four axes, they are colliding.

Applying SAT in 3D (OBB vs. OBB)

For 3D OBBs, the candidate separating axes are:

3 axes from OBB A,
3 axes from OBB B,
9 axes from the cross products of edges from A and B.

That makes a total of 15 axes. If projections overlap on all of them, the OBBs are colliding. If even one axis provides a gap, they are not.

The Projection Inequality (2D Example)

Let’s look at the math for testing overlap along one axis. Suppose we test along $A_x$ , an axis of rectangle A. The check is:

\cdot A_x| > W_A + |(W_B B_x) \cdot A_x| + |(H_B B_y) \cdot A_x|

Where:

$T$ is the vector from the center of A to the center of B,
$A_x, A_y$ are A’s axes,
$B_x, B_y$ are B’s axes,
$W_A, H_A$ are half-width and half-height of A,
$W_B, H_B$ are half-width and half-height of B.

The left-hand side represents the projected distance between the centers. The right-hand side represents the sum of the projected half-widths. If the distance is greater than the combined projection radius, the rectangles do not collide along this axis.

Computational Efficiency (FLOPs)

Each axis test requires only a handful of operations:

Dot products to compute projections,
Absolute values,
A few additions.

In total, a single axis test costs around 10–12 floating-point operations (FLOPs). In 2D, we only need around 40–50 FLOPs, while in 3D, testing 15 axes costs around 200 FLOPs. This is efficient enough for real-time collision detection.

Summary

AABB: Simple bounding box aligned with coordinate axes, tested with range overlap checks per axis.
OBB: Bounding box that rotates with the object, more accurate but requires SAT.
SAT: If a separating axis exists, shapes do not collide.
2D OBB: 4 axes need to be checked.
3D OBB: 15 axes need to be checked.
Efficiency: Only a few hundred FLOPs, practical for real-time use in games and simulations.

References

Plugin/Add-on Development to improve workflow in Unity

Pratyush Mohanty — Sun, 13 Jul 2025 11:05:55 +0000

In Unity, you can write C# scripts not just for game logic but also to automate tasks and improve your workflow. One powerful way to do this is by developing custom Editor tools that integrate directly into the Unity Editor itself.

Here’s a plugin I developed called MaxSizeFilterTool. This tool is particularly useful when importing complex 3D models that often include numerous small, unnecessary GameObjects — often invisible or insignificant to the final scene but still adding to poly count and clutter.

This plugin allows you to:

Select a parent GameObject (typically a model you imported),
View its children,
Filter child GameObjects based on their bounding box volume, and
Delete extremely small objects that contribute little to the visual output but increase complexity.

1. Make GUI for the plugin accessible from Tools menu , simple message displaying plugin

The plugin is an EditorWindow that appears in Unity’s Tools menu.

[MenuItem("Tools/Filter Small Objects")]
public static void ShowWindow()
{
    GetWindow<MaxSizeFilterTool>("Filter Small Objects");
}

This line adds an option to the Unity toolbar.
In OnEnable() and OnDisable(), we hook and unhook into Unity’s Scene GUI event, allowing us to draw bounding boxes in the 3D view:

2. Code for searching and selecting objects

To make selection easier, the tool includes a search bar and scroll list. It collects all scene GameObjects via:

private void RefreshObjectList()
{
    allObjects.Clear();
    allObjects.AddRange(FindObjectsOfType<GameObject>());
    filteredObjects = new List<GameObject>(allObjects);
}

This populates the list with all objects in the filtered list

filteredObjects = allObjects
    .Where(obj => string.IsNullOrEmpty(searchQuery) || obj.name.ToLower().Contains(searchQuery.ToLower()))
    .ToList();

Then a foreach loop generates clcikable buttons for each object in the filtered list

foreach (var obj in filteredObjects)
{
    if (GUILayout.Button(obj.name))
    {
        selectedObject = obj;
        GetObjectInfo(selectedObject);
    }
}

When clicked, the plugin sets the object as selected and calls GetObjectInfo() to analyze it.

3. Code for generating bounding box of the 3d model and the child game objects

The GetObjectInfo() function gathers several pieces of data:

Total number of child objects
Number of empty children (no mesh, no children)
Total triangle and vertex count
Combined bounding box volume

I was stuck witht he volume of the objects not being calculated opproperly and not "sticking" to the object co-ordinates while moving.

To fix this, I had to use the TransformPoint() and TransformVector() to convert local bounds to world space.

MeshFilter[] meshes = obj.GetComponentsInChildren<MeshFilter>();
Bounds combinedBounds = new Bounds(obj.transform.position, Vector3.zero);

foreach (var meshFilter in meshes)
{
    if (meshFilter.sharedMesh != null)
    {
        triangleCount += meshFilter.sharedMesh.triangles.Length / 3;
        vertexCount += meshFilter.sharedMesh.vertexCount;

        var bounds = meshFilter.sharedMesh.bounds;
        bounds.center = meshFilter.transform.TransformPoint(bounds.center);
        bounds.extents = meshFilter.transform.TransformVector(bounds.extents);
        combinedBounds.Encapsulate(bounds);
    }
}

objectVolume = combinedBounds.size.x * combinedBounds.size.y * combinedBounds.size.z;

4. Determining volume of the objects from the bounding box

The user can adjust a slider to define a minimum volume threshold. Child objects smaller than this will be displayed:

sliderValue = EditorGUILayout.Slider("Filter by Volume", sliderValue, 0f, objectVolume);

And then we can compute the volume for each child objects
and then list them

private float GetObjectVolume(GameObject obj)
{
    MeshFilter[] meshes = obj.GetComponentsInChildren<MeshFilter>();
    Bounds combinedBounds = new Bounds(obj.transform.position, Vector3.zero);

    foreach (var meshFilter in meshes)
    {
        if (meshFilter.sharedMesh != null)
        {
            var bounds = meshFilter.sharedMesh.bounds;
            bounds.center = meshFilter.transform.TransformPoint(bounds.center);
            bounds.extents = meshFilter.transform.TransformVector(bounds.extents);
            combinedBounds.Encapsulate(bounds);
        }
    }

    return combinedBounds.size.x * combinedBounds.size.y * combinedBounds.size.z;
}


private void DisplayAllDescendantObjectsWithVolumeLessThanSlider(Transform parentTransform, ref int filteredObjectCount)
{
    foreach (Transform child in parentTransform)
    {
        float childVolume = GetObjectVolume(child.gameObject);
        if (childVolume < sliderValue)
        {
            EditorGUILayout.LabelField($"Child Object: {child.gameObject.name} - Volume: {childVolume:F6}");
            filteredObjectCount++;
        }

        DisplayAllDescendantObjectsWithVolumeLessThanSlider(child, ref filteredObjectCount);
    }
}

4. Finishing Up

Here is some more sections containing undo support and deletion logic .

Deletion and undo code

private void DeleteFilteredObjects()
{
    lastDeletedObjects.Clear();
    lastDeletedCount = 0;

    foreach (Transform child in selectedObject.transform)
    {
        float childVolume = GetObjectVolume(child.gameObject);
        if (childVolume < sliderValue)
        {
            lastDeletedObjects.Add(child.gameObject);
            lastDeletedCount++;
        }
    }

    Undo.RegisterCompleteObjectUndo(selectedObject, "Delete Filtered Children");

    foreach (var obj in lastDeletedObjects)
    {
        Undo.DestroyObjectImmediate(obj);
    }

    GetObjectInfo(selectedObject);
    Repaint();
}

private void UndoLastDelete()
{
    if (lastDeletedCount > 0)
    {
        Undo.PerformUndo();
        lastDeletedCount = 0;
        lastDeletedObjects.Clear();
        GetObjectInfo(selectedObject);
        Repaint();
    }
}

To help visualize the object bounds, this plugin draws wireframe boxes in the Scene view:

private void OnSceneGUI(SceneView sceneView)
{
    if (selectedObject == null) return;

    if (showBoundingBox)
    {
        DrawBounds(selectedObject, Color.green);
    }

    if (showAllChildBounds)
    {
        foreach (Transform child in selectedObject.GetComponentsInChildren<Transform>())
        {
            DrawBounds(child.gameObject, new Color(1, 0.5f, 0, 0.5f));
        }
    }
}
private void DrawBounds(GameObject obj, Color color)
{
    MeshFilter[] meshes = obj.GetComponentsInChildren<MeshFilter>();
    if (meshes.Length == 0) return;

    Bounds combinedBounds = meshes[0].sharedMesh.bounds;
    combinedBounds.center = meshes[0].transform.TransformPoint(combinedBounds.center);
    combinedBounds.extents = meshes[0].transform.TransformVector(combinedBounds.extents);

    for (int i = 1; i < meshes.Length; i++)
    {
        if (meshes[i].sharedMesh != null)
        {
            var bounds = meshes[i].sharedMesh.bounds;
            bounds.center = meshes[i].transform.TransformPoint(bounds.center);
            bounds.extents = meshes[i].transform.TransformVector(bounds.extents);
            combinedBounds.Encapsulate(bounds);
        }
    }

    Handles.color = color;
    Handles.DrawWireCube(combinedBounds.center, combinedBounds.size);
}

Codebase

Access the code for this here
Code for MaxSizeFilterTool

Running llama3 in WSL2 using Docker in your PC 🐧🦙🐋

Pratyush Mohanty — Sat, 03 May 2025 03:05:25 +0000

In order to run Ollama in your local system, the best way is to use docker in the Windows Subsystem for Linux. This is a tutorial going over what needs to be done.

🐧 Installing WSL and Docker on Windows

This guide will walk you through setting up Windows Subsystem for Linux (WSL) and Docker inside WSL on a Windows machine.

1. Enable WSL

Open PowerShell as Administrator and run:

wsl --install

This installs Ubuntu as the default distribution. If WSL 2 isn't already enabled, this command handles it too.

Reboot Your PC

This will install Ubuntu. Once done, restart your PC to complete the setup.

Set Up Your Linux Distribution

After reboot, WSL will launch and prompt you to create a username and password.

If it doesn't launch automatically, run:

wsl

Or launch Ubuntu from the Start Menu.

Update Ubuntu

Inside WSL terminal:

sudo apt update && sudo apt upgrade -y

2. 🐳Install Docker in WSL (Ubuntu)

Instructions taken from Docker Ubuntu Installation.

Add the repository to Apt sources:

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Install the Docker packages.

To install the latest version, run:

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Run Docker without `sudo`

(Optional but recommended):

sudo usermod -aG docker $USER

Then restart WSL or your terminal:

exit

And open it again. Test with:

docker run hello-world

The following screen should be visible

3. 🦙 Installing Ollama in the WSL Ubuntu Environment

We will install and run Ollama using Docker, following the instructions on the official to access the docker Image Ollama Docker page.

Since I’m running this on a laptop without GPU support, I opted for the CPU version. If you have a GPU, using the GPU version is highly recommended for better performance.

1. Run the Docker container:

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

2. Run a model (e.g., llama3):

docker exec -it ollama ollama run llama3

This will download and run the llama3 model (or whichever model you specify). You can now interact with it.

Use the command below to see help and available options:

/?

3. Starting Ollama on future sessions:

When you reopen WSL, you can start the container using:

docker start ollama

Then, re-run your desired model:

docker exec -it ollama ollama run llama3

4. Accessing via browser or client:

Once running, visit:

http://localhost:11434

You should see a response like:

{"message":"Ollama is running"}

5. To stop Ollama:

docker stop ollama