- Home /

# Calculate Bounds Intersection Face Normal

I am trying to calculate the normal of the face of the bounds (axis aligned) that a ray intersects. There are a couple modifications to the normal problem of bounds intersections (ray-box intersection) I have made:

Ray direction is guaranteed to be normalized

I only need the closest point in front of the ray if any (solved in the IntersectBounds method already)

From this I can find the position of intersection regardless of ray origin and direction.

What I really need is the normal of the face it hit. This isn't a raycasting or mesh lookup problem and is purely algebraic as this is used in a compute shader.

Due to this being on the **GPU** when normally executed, floating point precision is a factor and I am looking for a reliable way to find the normal without just enumerating each face and checking if it's close enough.

Any help is appreciated; a formula or equation of some kind is ideal here. Thank you!

Example code:

```
using UnityEngine;
[RequireComponent(typeof(MeshRenderer))]
public class BoundsIntersection : MonoBehaviour {
public Vector3 origin = Vector3.zero;
public Vector3 direction = Vector3.one;
private void OnDrawGizmos() {
MeshRenderer rend = GetComponent<MeshRenderer>();
Bounds b = rend.bounds;
// draw bounds, min, max points
Gizmos.color = Color.white;
Gizmos.DrawWireCube(b.center, b.size);
Gizmos.DrawWireCube(b.min, Vector3.one * 0.05f);
Gizmos.DrawWireCube(b.max, Vector3.one * 0.05f);
Ray r = new Ray(origin, direction.normalized);
Gizmos.color = Color.red;
Gizmos.DrawRay(r);
float t = IntersectBounds(r, b);
if (t > 0) {
Gizmos.color = Color.blue;
Gizmos.DrawLine(origin, origin + r.direction * t);
Gizmos.DrawWireSphere(origin + r.direction * t, 0.05f);
}
}
float IntersectBounds(Ray ray, Bounds bounds) {
// points on infinite axis that ray intersects, defined by bounds
// we need to keep considering the max to make sure the min is correct
float txmin, txmax, tymin, tymax, tzmin, tzmax;
// solve divie by 0 issues
Vector3 invDir = new Vector3(1f / ray.direction.x, 1f / ray.direction.y, 1f / ray.direction.z);
if (invDir.x >= 0) {
txmin = (bounds.min.x - ray.origin.x) * invDir.x;
txmax = (bounds.max.x - ray.origin.x) * invDir.x;
} else {
txmin = (bounds.max.x - ray.origin.x) * invDir.x;
txmax = (bounds.min.x - ray.origin.x) * invDir.x;
}
if (invDir.y >= 0) {
tymin = (bounds.min.y - ray.origin.y) * invDir.y;
tymax = (bounds.max.y - ray.origin.y) * invDir.y;
} else {
tymin = (bounds.max.y - ray.origin.y) * invDir.y;
tymax = (bounds.min.y - ray.origin.y) * invDir.y;
}
if ((txmin > tymax) || (tymin > txmax)) return 0.0f;
// moves bounds in to leave only a 2d plane to check (x-z plane)
if (tymin > txmin) txmin = tymin;
if (tymax < txmax) txmax = tymax;
if (invDir.z >= 0) {
tzmin = (bounds.min.z - ray.origin.z) * invDir.z;
tzmax = (bounds.max.z - ray.origin.z) * invDir.z;
} else {
tzmin = (bounds.max.z - ray.origin.z) * invDir.z;
tzmax = (bounds.min.z - ray.origin.z) * invDir.z;
}
if ((txmin > tzmax) || (tzmin > txmax)) return 0.0f;
if (tzmin > txmin) txmin = tzmin;
if (tzmax < txmax) txmax = tzmax;
if (txmin <= 0f) {
if (txmax <= 0f) return 0f;
return txmax;
}
return txmin;
}
}
```

What it looks like in scene with cube near the ray (ray kept at default 0, 0, 0 origin and 1, 1, 1 direction)

Silly question, but have you tried RaycastHit.normal? Does it give you the wrong normal?

Unfortunately, I am not using Unity raycasting. I have the bounds and a ray on the GPU ins$$anonymous$$d of on the Unity processing threads. I am trying to figure this out using only the bounds min and max points and the ray origin and direction since I don't have access to the physic space of the scene, and these are just bounds of meshes ins$$anonymous$$d of their actual physics shapes. I should note that the example is so that it can be visualized but will actually be running in a compute shader on the GPU.

Okay I see what you mean. I've not tried something like this myself, but I might be able to help with the math.

You could use the mesh's normal array to sort out which normal it is you need.

If your contact point is **on** a face then a vector between the **contact point** and the face's **normal vector's origin** will always be perpendicular to the normal vector **of that face**, and not to any other. (This gets a little tricky around the edges and when the contact point is close to the normal's origin, but should be okay with floats)

So you could just go through the normals array in the mesh, draw vectors and check angles. You can also compare angles and get the one closest to perpendicular to eliminate unlikely results. (If your contact point isn't precisely on the face, or if the geometry is complex enough you could get more than one likely result).

### Your answer

### Welcome to Unity Answers

The best place to ask and answer questions about development with Unity.

To help users navigate the site we have posted a site navigation guide.

If you are a new user to Unity Answers, check out our FAQ for more information.

Make sure to check out our Knowledge Base for commonly asked Unity questions.

If you are a moderator, see our Moderator Guidelines page.

We are making improvements to UA, see the list of changes.

### Follow this Question

### Related Questions

What's the best/easiest way to do something like Bounds.Intersects but accounting for rotation? 1 Answer

Problem with getting colliding objects 3 Answers

Mesh collider not working as expected 2 Answers

Check if mesh.bounds intersect a plane 1 Answer

Surface Intersection of procedural shapes to find vertex normals? 0 Answers