74 lines
2.9 KiB
Markdown
74 lines
2.9 KiB
Markdown
# Step 06 — Ray vs AABB (two sweeps become one hit)
|
|
|
|
This is where step 04 ("collision = the AND of two 1D tests") and step 05 ("the
|
|
entry/exit time of one sweep") finally fuse. A **moving point vs a static box**.
|
|
|
|
## Concept
|
|
|
|
A point at `p` moves by `v` over the frame. A static box has a left/right edge
|
|
(its x-interval) and a top/bottom edge (its y-interval). The point is inside the
|
|
**box** only while it's inside the x-interval **and** the y-interval *at the same
|
|
time*.
|
|
|
|
So run `sweepInterval` twice:
|
|
|
|
```
|
|
spanX = sweepInterval(p.x, v.x, box.x, box.x + box.w) // the x-edges
|
|
spanY = sweepInterval(p.y, v.y, box.y, box.y + box.h) // the y-edges
|
|
```
|
|
|
|
Each gives you a time-window `[entry, exit]` during which the point is inside
|
|
*that one axis's* strip. You're inside the box during the **overlap of the two
|
|
windows**:
|
|
|
|
```
|
|
entry = max(spanX.entry, spanY.entry) // inside the box once you're inside the LAST axis
|
|
exit = min(spanX.exit, spanY.exit) // out of the box once you leave the FIRST axis
|
|
```
|
|
|
|
Read those two lines until they feel obvious — they're the whole algorithm:
|
|
|
|
- You're only truly *inside the box* once you've entered **both** strips, so the
|
|
real entry is the **later** of the two entries → `max`.
|
|
- You **leave** the box the instant you exit **either** strip → the **earlier**
|
|
exit → `min`.
|
|
|
|
### When is there NO hit?
|
|
|
|
1. **A span is `null`** — on some axis the point isn't moving and is already
|
|
outside that strip. It can never be inside the box. Return `null` immediately.
|
|
2. **`entry > exit`** — the two windows never overlap. The point is inside one
|
|
strip, then the other, but never both at once. That's the classic "flies past
|
|
the corner" miss.
|
|
3. **`entry >= 1` or `exit <= 0`** — the windows overlap, but not *during this
|
|
frame* (it's entirely in the future, or entirely in the past). Not our problem
|
|
this frame.
|
|
|
|
### The normal (which wall did we hit?)
|
|
|
|
When you do collide, you also want to know **which face** you hit, so the response
|
|
later can push you back the right way. That's the `normal` — a unit vector
|
|
pointing out of the surface you struck.
|
|
|
|
The trick: **the axis you entered *last* is the axis you actually hit.** Compare
|
|
the two entry times — whichever is larger is the blocking axis:
|
|
|
|
- if `spanX.entry > spanY.entry` → you hit a **vertical** wall (left/right face).
|
|
The normal is horizontal, pointing back against your x-motion:
|
|
`normal = { x: v.x > 0 ? -1 : 1, y: 0 }`.
|
|
- otherwise → you hit a **horizontal** wall (top/bottom). The normal is vertical:
|
|
`normal = { x: 0, y: v.y > 0 ? -1 : 1 }`.
|
|
|
|
(Moving right and hitting something → the surface pushes you left → normal `-1`.
|
|
That sign rule is all there is to it.)
|
|
|
|
## Task
|
|
|
|
Implement `rayVsAABB(p, v, box)` in `ray.ts`. Return `{ time, normal }` for the
|
|
entry, or `null` for any of the three no-hit cases. `sweepInterval` is provided
|
|
in `given.ts` — **reuse it**, don't re-derive it.
|
|
|
|
```sh
|
|
bun test workshop/steps/06-ray-vs-aabb
|
|
```
|