66 lines
2.4 KiB
TypeScript
66 lines
2.4 KiB
TypeScript
import type { Mat4 } from "../math/Mat4"
|
|
|
|
/** The six view-frustum planes packed as (a, b, c, d) each, normal pointing
|
|
* inward: a point is inside a plane when a*x + b*y + c*z + d >= 0. */
|
|
export type Frustum = Float32Array
|
|
|
|
export namespace Frustum {
|
|
/** Extract the planes from a view-projection matrix (Gribb-Hartmann). Our Mat4
|
|
* is column-major (`m[col*4 + row]`), so a clip-space row `i` gathers the
|
|
* `i`-th entry of every column. Left/right/bottom/top/near/far are the row
|
|
* sums/differences with the w-row. */
|
|
export function fromViewProj(m: Mat4): Frustum {
|
|
const rx = [m[0], m[1], m[2], m[3]]
|
|
const ry = [m[4], m[5], m[6], m[7]]
|
|
const rz = [m[8], m[9], m[10], m[11]]
|
|
const rw = [m[12], m[13], m[14], m[15]]
|
|
// Row i of the clip matrix = (rx[i], ry[i], rz[i], rw[i]).
|
|
const row = (i: number): [number, number, number, number] => [rx[i], ry[i], rz[i], rw[i]]
|
|
const [x0, y0, z0, w0] = row(0)
|
|
const [x1, y1, z1, w1] = row(1)
|
|
const [x2, y2, z2, w2] = row(2)
|
|
const [x3, y3, z3, w3] = row(3)
|
|
const f = new Float32Array(24)
|
|
plane(f, 0, x3 + x0, y3 + y0, z3 + z0, w3 + w0) // left
|
|
plane(f, 1, x3 - x0, y3 - y0, z3 - z0, w3 - w0) // right
|
|
plane(f, 2, x3 + x1, y3 + y1, z3 + z1, w3 + w1) // bottom
|
|
plane(f, 3, x3 - x1, y3 - y1, z3 - z1, w3 - w1) // top
|
|
plane(f, 4, x3 + x2, y3 + y2, z3 + z2, w3 + w2) // near
|
|
plane(f, 5, x3 - x2, y3 - y2, z3 - z2, w3 - w2) // far
|
|
return f
|
|
}
|
|
|
|
/** True if the axis-aligned box might be visible. Conservative: tests the box
|
|
* corner farthest along each plane normal; the box is culled only if that
|
|
* corner is still outside some plane, so nothing visible is ever dropped. */
|
|
export function intersectsAabb(
|
|
f: Frustum,
|
|
minX: number,
|
|
minY: number,
|
|
minZ: number,
|
|
maxX: number,
|
|
maxY: number,
|
|
maxZ: number,
|
|
): boolean {
|
|
for (let p = 0; p < 24; p += 4) {
|
|
const a = f[p]
|
|
const b = f[p + 1]
|
|
const c = f[p + 2]
|
|
const px = a >= 0 ? maxX : minX
|
|
const py = b >= 0 ? maxY : minY
|
|
const pz = c >= 0 ? maxZ : minZ
|
|
if (a * px + b * py + c * pz + f[p + 3] < 0) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
function plane(f: Frustum, i: number, a: number, b: number, c: number, d: number): void {
|
|
const inv = 1 / Math.hypot(a, b, c)
|
|
f[i * 4] = a * inv
|
|
f[i * 4 + 1] = b * inv
|
|
f[i * 4 + 2] = c * inv
|
|
f[i * 4 + 3] = d * inv
|
|
}
|
|
}
|