@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/nav/mesh/regions.js

@@ -0,0 +1,367 @@
+/**
+ * Navmesh bake, stage two: regions. A monotone sweep gives every walkable span a region such
+ * that no region has a hole; small regions then merge into a neighbour when the merge stays
+ * hole-free, and islands below `minRegionArea` are dropped. Recast's `rcBuildRegionsMonotone`
+ * and `mergeAndFilterRegions`, in cells.
+ */
+import { NOT_CONNECTED, NULL_AREA } from './voxelize.js';
+const NULL_NEI = 0xffff;
+function newRegion(id) {
+    return {
+        spanCount: 0,
+        id,
+        areaType: 0,
+        remap: false,
+        visited: false,
+        overlap: false,
+        connections: [],
+        floors: [],
+    };
+}
+function isSolidEdge(chf, srcReg, i, dir) {
+    const ai = chf.con[i * 4 + dir];
+    const r = ai !== NOT_CONNECTED ? srcReg[ai] : 0;
+    return r !== srcReg[i];
+}
+/** Walks a region's boundary and lists the neighbour regions met, in order (RecastRegion `walkContour`). */
+function walkContour(i0, dir0, chf, srcReg, cont) {
+    let i = i0;
+    let dir = dir0;
+    let curReg = 0;
+    const ai0 = chf.con[i * 4 + dir];
+    if (ai0 !== NOT_CONNECTED)
+        curReg = srcReg[ai0];
+    cont.push(curReg);
+    let iter = 0;
+    while (++iter < 40000) {
+        if (isSolidEdge(chf, srcReg, i, dir)) {
+            const ai = chf.con[i * 4 + dir];
+            const r = ai !== NOT_CONNECTED ? srcReg[ai] : 0;
+            if (r !== curReg) {
+                curReg = r;
+                cont.push(curReg);
+            }
+            dir = (dir + 1) & 3;
+        }
+        else {
+            const ni = chf.con[i * 4 + dir];
+            if (ni === NOT_CONNECTED)
+                return;
+            i = ni;
+            dir = (dir + 3) & 3;
+        }
+        if (i0 === i && dir0 === dir)
+            break;
+    }
+    // Remove adjacent duplicates.
+    if (cont.length > 1) {
+        for (let j = 0; j < cont.length;) {
+            const nj = (j + 1) % cont.length;
+            if (cont[j] === cont[nj])
+                cont.splice(j, 1);
+            else
+                j++;
+        }
+    }
+}
+function removeAdjacentNeighbours(reg) {
+    const c = reg.connections;
+    for (let i = 0; i < c.length && c.length > 1;) {
+        const ni = (i + 1) % c.length;
+        if (c[i] === c[ni])
+            c.splice(i, 1);
+        else
+            i++;
+    }
+}
+function replaceNeighbour(reg, oldId, newId) {
+    let changed = false;
+    for (let i = 0; i < reg.connections.length; i++) {
+        if (reg.connections[i] === oldId) {
+            reg.connections[i] = newId;
+            changed = true;
+        }
+    }
+    for (let i = 0; i < reg.floors.length; i++)
+        if (reg.floors[i] === oldId)
+            reg.floors[i] = newId;
+    if (changed)
+        removeAdjacentNeighbours(reg);
+}
+function canMergeWithRegion(rega, regb) {
+    if (rega.areaType !== regb.areaType)
+        return false;
+    let n = 0;
+    for (const c of rega.connections)
+        if (c === regb.id)
+            n++;
+    if (n > 1)
+        return false;
+    for (const f of rega.floors)
+        if (f === regb.id)
+            return false;
+    return true;
+}
+function addUniqueFloorRegion(reg, n) {
+    if (!reg.floors.includes(n))
+        reg.floors.push(n);
+}
+function mergeRegions(rega, regb) {
+    const aid = rega.id;
+    const bid = regb.id;
+    const acon = rega.connections.slice();
+    const bcon = regb.connections;
+    const insa = acon.indexOf(bid);
+    if (insa === -1)
+        return false;
+    const insb = bcon.indexOf(aid);
+    if (insb === -1)
+        return false;
+    rega.connections = [];
+    for (let i = 0, ni = acon.length; i < ni - 1; i++)
+        rega.connections.push(acon[(insa + 1 + i) % ni]);
+    for (let i = 0, ni = bcon.length; i < ni - 1; i++)
+        rega.connections.push(bcon[(insb + 1 + i) % ni]);
+    removeAdjacentNeighbours(rega);
+    for (const f of regb.floors)
+        addUniqueFloorRegion(rega, f);
+    rega.spanCount += regb.spanCount;
+    regb.spanCount = 0;
+    regb.connections = [];
+    return true;
+}
+function isRegionConnectedToBorder(reg) {
+    return reg.connections.includes(0);
+}
+/** Removes islands under `minRegionArea`, merges small regions, compacts ids; returns the region count. */
+function mergeAndFilterRegions(chf, minRegionArea, mergeRegionSize, maxRegionId, srcReg) {
+    const w = chf.width;
+    const h = chf.height;
+    const nreg = maxRegionId + 1;
+    const regions = [];
+    for (let i = 0; i < nreg; i++)
+        regions.push(newRegion(i));
+    for (let z = 0; z < h; z++) {
+        for (let x = 0; x < w; x++) {
+            const c = x + z * w;
+            const start = chf.cellIndex[c];
+            const end = start + chf.cellCount[c];
+            for (let i = start; i < end; i++) {
+                const r = srcReg[i];
+                if (r === 0 || r >= nreg)
+                    continue;
+                const reg = regions[r];
+                reg.spanCount++;
+                for (let j = start; j < end; j++) {
+                    if (i === j)
+                        continue;
+                    const floorId = srcReg[j];
+                    if (floorId === 0 || floorId >= nreg)
+                        continue;
+                    if (floorId === r)
+                        reg.overlap = true;
+                    addUniqueFloorRegion(reg, floorId);
+                }
+                if (reg.connections.length > 0)
+                    continue;
+                reg.areaType = chf.areas[i];
+                let ndir = -1;
+                for (let dir = 0; dir < 4; dir++) {
+                    if (isSolidEdge(chf, srcReg, i, dir)) {
+                        ndir = dir;
+                        break;
+                    }
+                }
+                if (ndir !== -1)
+                    walkContour(i, ndir, chf, srcReg, reg.connections);
+            }
+        }
+    }
+    // Remove too small regions.
+    const stack = [];
+    const trace = [];
+    for (let i = 0; i < nreg; i++) {
+        const reg = regions[i];
+        if (reg.id === 0)
+            continue;
+        if (reg.spanCount === 0)
+            continue;
+        if (reg.visited)
+            continue;
+        let spanCount = 0;
+        stack.length = 0;
+        trace.length = 0;
+        reg.visited = true;
+        stack.push(i);
+        while (stack.length > 0) {
+            const ri = stack.pop();
+            const creg = regions[ri];
+            spanCount += creg.spanCount;
+            trace.push(ri);
+            for (const nei of creg.connections) {
+                // 0 is the null region (the world's edge or an obstacle), never a region to visit.
+                if (nei === 0)
+                    continue;
+                const neireg = regions[nei];
+                if (neireg.visited)
+                    continue;
+                if (neireg.id === 0)
+                    continue;
+                stack.push(nei);
+                neireg.visited = true;
+            }
+        }
+        if (spanCount < minRegionArea) {
+            for (const ri of trace) {
+                regions[ri].spanCount = 0;
+                regions[ri].id = 0;
+            }
+        }
+    }
+    // Merge too small regions to neighbour regions.
+    let mergeCount;
+    do {
+        mergeCount = 0;
+        for (let i = 0; i < nreg; i++) {
+            const reg = regions[i];
+            if (reg.id === 0)
+                continue;
+            if (reg.overlap)
+                continue;
+            if (reg.spanCount === 0)
+                continue;
+            if (reg.spanCount > mergeRegionSize && isRegionConnectedToBorder(reg))
+                continue;
+            let smallest = 0xfffffff;
+            let mergeId = reg.id;
+            for (const nei of reg.connections) {
+                if (nei === 0)
+                    continue;
+                const mreg = regions[nei];
+                if (mreg.id === 0 || mreg.overlap)
+                    continue;
+                if (mreg.spanCount < smallest &&
+                    canMergeWithRegion(reg, mreg) &&
+                    canMergeWithRegion(mreg, reg)) {
+                    smallest = mreg.spanCount;
+                    mergeId = mreg.id;
+                }
+            }
+            if (mergeId !== reg.id) {
+                const oldId = reg.id;
+                const target = regions[mergeId];
+                if (mergeRegions(target, reg)) {
+                    for (let j = 0; j < nreg; j++) {
+                        const rj = regions[j];
+                        if (rj.id === 0)
+                            continue;
+                        if (rj.id === oldId)
+                            rj.id = mergeId;
+                        replaceNeighbour(rj, oldId, mergeId);
+                    }
+                    mergeCount++;
+                }
+            }
+        }
+    } while (mergeCount > 0);
+    // Compress region ids.
+    for (let i = 0; i < nreg; i++) {
+        regions[i].remap = false;
+        if (regions[i].id === 0)
+            continue;
+        regions[i].remap = true;
+    }
+    let regIdGen = 0;
+    for (let i = 0; i < nreg; i++) {
+        if (!regions[i].remap)
+            continue;
+        const oldId = regions[i].id;
+        const newId = ++regIdGen;
+        for (let j = i; j < nreg; j++) {
+            if (regions[j].id === oldId) {
+                regions[j].id = newId;
+                regions[j].remap = false;
+            }
+        }
+    }
+    for (let i = 0; i < chf.spanCount; i++)
+        srcReg[i] = regions[srcReg[i]].id;
+    return regIdGen;
+}
+/**
+ * Assigns a region to every walkable span (`chf.regs`; 0 is none) and sets `chf.maxRegions`.
+ * `minRegionArea` and `mergeRegionArea` are in cells.
+ */
+export function buildRegions(chf, minRegionArea, mergeRegionArea) {
+    const w = chf.width;
+    const h = chf.height;
+    const srcReg = new Uint16Array(chf.spanCount);
+    const sweeps = [];
+    for (let i = 0; i < w + 2; i++)
+        sweeps.push({ rid: 0, id: 0, ns: 0, nei: 0 });
+    let prev = new Int32Array(256);
+    let regId = 1;
+    for (let z = 0; z < h; z++) {
+        if (prev.length < regId + 1)
+            prev = new Int32Array(Math.max(regId + 1, prev.length * 2));
+        prev.fill(0, 0, regId + 1);
+        let rid = 1;
+        for (let x = 0; x < w; x++) {
+            const c = x + z * w;
+            const end = chf.cellIndex[c] + chf.cellCount[c];
+            for (let i = chf.cellIndex[c]; i < end; i++) {
+                if (chf.areas[i] === NULL_AREA)
+                    continue;
+                // -x
+                let previd = 0;
+                const ai0 = chf.con[i * 4 + 0];
+                if (ai0 !== NOT_CONNECTED && chf.areas[i] === chf.areas[ai0])
+                    previd = srcReg[ai0];
+                if (previd === 0) {
+                    previd = rid++;
+                    const sw = sweeps[previd];
+                    sw.rid = previd;
+                    sw.ns = 0;
+                    sw.nei = 0;
+                }
+                // -z
+                const ai3 = chf.con[i * 4 + 3];
+                if (ai3 !== NOT_CONNECTED && chf.areas[i] === chf.areas[ai3]) {
+                    const nr = srcReg[ai3];
+                    if (nr !== 0) {
+                        const sw = sweeps[previd];
+                        if (sw.nei === 0 || sw.nei === nr) {
+                            sw.nei = nr;
+                            sw.ns++;
+                            prev[nr]++;
+                        }
+                        else {
+                            sw.nei = NULL_NEI;
+                        }
+                    }
+                }
+                srcReg[i] = previd;
+            }
+        }
+        // Create unique ids.
+        for (let i = 1; i < rid; i++) {
+            const sw = sweeps[i];
+            if (sw.nei !== NULL_NEI && sw.nei !== 0 && prev[sw.nei] === sw.ns)
+                sw.id = sw.nei;
+            else
+                sw.id = regId++;
+        }
+        // Remap ids.
+        for (let x = 0; x < w; x++) {
+            const c = x + z * w;
+            const end = chf.cellIndex[c] + chf.cellCount[c];
+            for (let i = chf.cellIndex[c]; i < end; i++) {
+                if (srcReg[i] > 0)
+                    srcReg[i] = sweeps[srcReg[i]].id;
+            }
+        }
+    }
+    const maxRegionId = mergeAndFilterRegions(chf, minRegionArea, mergeRegionArea, regId - 1, srcReg);
+    chf.maxRegions = maxRegionId;
+    chf.regs.set(srcReg);
+}

package/dist/nav/mesh/serialize.d.ts

@@ -0,0 +1,13 @@
+import { NavMesh } from './navmesh.js';
+/** Serialises the mesh (polygons, adjacency, areas, links) into a fresh buffer. */
+export declare function exportNavMesh(mesh: NavMesh): ArrayBuffer;
+/** Rebuilds a mesh from `exportNavMesh` bytes; throws on a buffer that is not one. */
+export declare function importNavMesh(buffer: ArrayBuffer | ArrayBufferView): NavMesh;
+/**
+ * Loads a navmesh shipped as bytes (a `pnpm bake:nav` or `pnpm bake` output, read with `fetch`
+ * or a `bytes` bundle entry): `importNavMesh`, then checks what a corrupt or truncated file would
+ * break later, so a bad asset fails at load with a reason instead of inside a query. Throws when
+ * the buffer is not a navmesh, is shorter than its header says, or holds a vertex index, an
+ * adjacency entry or a coordinate out of range.
+ */
+export declare function loadNavMesh(bytes: ArrayBuffer | ArrayBufferView): NavMesh;

package/dist/nav/mesh/serialize.js

@@ -0,0 +1,197 @@
+/**
+ * Navmesh bytes: bake at build time, ship the buffer, `importNavMesh` at load. Little-endian,
+ * self-describing header; areas and off-mesh links travel with the mesh (their `userData` does
+ * not). Format 2 (ws/nav-4) adds the area bytes; format 1 buffers load with every area 0.
+ */
+import { addOffMeshLink } from './links.js';
+import { NavMesh } from './navmesh.js';
+const MAGIC = 0x4e41564d; // 'NAVM'
+/** Format 2 appends the area byte per polygon (padded to 4 bytes); format 1 bytes still load with every area 0. */
+const FORMAT = 2;
+const HEADER_U32 = 7;
+const LINK_F32 = 10;
+function areaBytes(polyCount) {
+    return (polyCount + 3) & ~3;
+}
+/** Serialises the mesh (polygons, adjacency, areas, links) into a fresh buffer. */
+export function exportNavMesh(mesh) {
+    const nvp = mesh.maxVertsPerPoly;
+    const links = mesh.links.filter((l) => l !== null);
+    const bytes = HEADER_U32 * 4 +
+        2 * 4 +
+        6 * 4 +
+        mesh.vertCount * 3 * 4 +
+        mesh.polyCount * nvp * 4 * 2 +
+        areaBytes(mesh.polyCount) +
+        links.length * LINK_F32 * 4;
+    const buffer = new ArrayBuffer(bytes);
+    const view = new DataView(buffer);
+    let o = 0;
+    const u32 = (v) => {
+        view.setUint32(o, v, true);
+        o += 4;
+    };
+    const i32 = (v) => {
+        view.setInt32(o, v, true);
+        o += 4;
+    };
+    const f32 = (v) => {
+        view.setFloat32(o, v, true);
+        o += 4;
+    };
+    u32(MAGIC);
+    u32(FORMAT);
+    u32(nvp);
+    u32(mesh.vertCount);
+    u32(mesh.polyCount);
+    u32(links.length);
+    u32(mesh.nextLinkId);
+    f32(mesh.cellSize);
+    f32(mesh.cellHeight);
+    f32(mesh.bounds.min.x);
+    f32(mesh.bounds.min.y);
+    f32(mesh.bounds.min.z);
+    f32(mesh.bounds.max.x);
+    f32(mesh.bounds.max.y);
+    f32(mesh.bounds.max.z);
+    for (let i = 0; i < mesh.vertCount * 3; i++)
+        f32(mesh.verts[i]);
+    for (let i = 0; i < mesh.polyCount * nvp; i++)
+        i32(mesh.polys[i]);
+    for (let i = 0; i < mesh.polyCount * nvp; i++)
+        i32(mesh.adjacency[i]);
+    new Uint8Array(buffer, o, mesh.polyCount).set(mesh.area.subarray(0, mesh.polyCount));
+    o += areaBytes(mesh.polyCount);
+    for (const l of links) {
+        f32(l.from.x);
+        f32(l.from.y);
+        f32(l.from.z);
+        f32(l.to.x);
+        f32(l.to.y);
+        f32(l.to.z);
+        f32(l.radius);
+        f32(l.cost ?? Number.NaN);
+        u32(l.bidirectional ? 1 : 0);
+        u32(l.id);
+    }
+    return buffer;
+}
+/** Rebuilds a mesh from `exportNavMesh` bytes; throws on a buffer that is not one. */
+export function importNavMesh(buffer) {
+    const view = buffer instanceof ArrayBuffer
+        ? new DataView(buffer)
+        : new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let o = 0;
+    const u32 = () => {
+        const v = view.getUint32(o, true);
+        o += 4;
+        return v;
+    };
+    const f32 = () => {
+        const v = view.getFloat32(o, true);
+        o += 4;
+        return v;
+    };
+    if (view.byteLength < HEADER_U32 * 4 || u32() !== MAGIC)
+        throw new Error('importNavMesh: not a navmesh buffer');
+    const format = u32();
+    if (format !== 1 && format !== FORMAT)
+        throw new Error(`importNavMesh: unsupported format ${format}`);
+    const nvp = u32();
+    const vertCount = u32();
+    const polyCount = u32();
+    const linkCount = u32();
+    const nextLinkId = u32();
+    const cs = f32();
+    const ch = f32();
+    o += 6 * 4; // bounds are recomputed from the vertices
+    const verts = new Float32Array(Math.max(1, vertCount) * 3);
+    for (let i = 0; i < vertCount * 3; i++)
+        verts[i] = f32();
+    const polys = new Int32Array(Math.max(1, polyCount) * nvp).fill(-1);
+    for (let i = 0; i < polyCount * nvp; i++) {
+        polys[i] = view.getInt32(o, true);
+        o += 4;
+    }
+    const adjacency = new Int32Array(Math.max(1, polyCount) * nvp).fill(-1);
+    for (let i = 0; i < polyCount * nvp; i++) {
+        adjacency[i] = view.getInt32(o, true);
+        o += 4;
+    }
+    const area = new Uint8Array(Math.max(1, polyCount));
+    if (format >= 2) {
+        area.set(new Uint8Array(view.buffer, view.byteOffset + o, polyCount));
+        o += areaBytes(polyCount);
+    }
+    const mesh = new NavMesh(verts, vertCount, polys, polyCount, nvp, cs, ch, adjacency, area);
+    for (let i = 0; i < linkCount; i++) {
+        const from = { x: f32(), y: f32(), z: f32() };
+        const to = { x: f32(), y: f32(), z: f32() };
+        const radius = f32();
+        const cost = f32();
+        const bidirectional = u32() === 1;
+        const id = u32();
+        mesh.nextLinkId = id;
+        addOffMeshLink(mesh, {
+            from,
+            to,
+            radius,
+            bidirectional,
+            cost: Number.isNaN(cost) ? undefined : cost,
+        });
+    }
+    mesh.nextLinkId = nextLinkId;
+    mesh.version = 0;
+    return mesh;
+}
+/**
+ * Loads a navmesh shipped as bytes (a `pnpm bake:nav` or `pnpm bake` output, read with `fetch`
+ * or a `bytes` bundle entry): `importNavMesh`, then checks what a corrupt or truncated file would
+ * break later, so a bad asset fails at load with a reason instead of inside a query. Throws when
+ * the buffer is not a navmesh, is shorter than its header says, or holds a vertex index, an
+ * adjacency entry or a coordinate out of range.
+ */
+export function loadNavMesh(bytes) {
+    const length = bytes.byteLength;
+    let mesh;
+    try {
+        mesh = importNavMesh(bytes);
+    }
+    catch (e) {
+        throw new Error(`loadNavMesh: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const nvp = mesh.maxVertsPerPoly;
+    const links = mesh.links.reduce((n, l) => (l ? n + 1 : n), 0);
+    const expected = HEADER_U32 * 4 +
+        8 * 4 +
+        mesh.vertCount * 12 +
+        mesh.polyCount * nvp * 8 +
+        areaBytes(mesh.polyCount) +
+        links * LINK_F32 * 4;
+    // Format 1 has no area block.
+    if (length !== expected && length !== expected - areaBytes(mesh.polyCount)) {
+        throw new Error(`loadNavMesh: ${length} bytes, the header describes ${expected}`);
+    }
+    if (nvp < 3 || nvp > 6)
+        throw new Error(`loadNavMesh: ${nvp} vertices per polygon`);
+    for (let i = 0; i < mesh.vertCount * 3; i++) {
+        if (!Number.isFinite(mesh.verts[i]))
+            throw new Error(`loadNavMesh: vertex ${(i / 3) | 0} is not finite`);
+    }
+    for (let p = 0; p < mesh.polyCount; p++) {
+        const n = mesh.polyVertexCount(p);
+        if (n < 3)
+            throw new Error(`loadNavMesh: polygon ${p} has ${n} vertices`);
+        for (let k = 0; k < nvp; k++) {
+            const v = mesh.polys[p * nvp + k];
+            const adj = mesh.adjacency[p * nvp + k];
+            if (k < n && !(v >= 0 && v < mesh.vertCount)) {
+                throw new Error(`loadNavMesh: polygon ${p} names vertex ${v}`);
+            }
+            if (adj < -1 || adj >= mesh.polyCount || (k >= n && adj !== -1)) {
+                throw new Error(`loadNavMesh: polygon ${p} edge ${k} names neighbour ${adj}`);
+            }
+        }
+    }
+    return mesh;
+}

package/dist/nav/mesh/voxelize.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Navmesh bake, stage one: triangles to a heightfield of spans, the walkability filters, the
+ * compact heightfield (one record per walkable span with its four neighbours) and the erosion
+ * by agent radius. The method is Recast's; the units inside are cells (`cellSize` across,
+ * `cellHeight` up). Bake-time code: it allocates freely, queries never run here.
+ */
+/** Triangle soup to bake: positions as x, y, z (every `stride` floats, from `offset`) and indices. */
+export interface NavBakeSource {
+    positions: ArrayLike<number>;
+    indices: ArrayLike<number>;
+    /** Floats per vertex in `positions` (3 for a bare position array, 12 for `geom`'s layout). Default 3. */
+    stride?: number;
+    /** Float index of the first vertex's x inside its stride. Default 0. */
+    offset?: number;
+}
+/**
+ * How to bake. Only `cellSize` is required; every other field has a default derived from it
+ * (`resolveNavBakeOptions`), and a non-finite or out-of-range value throws a `NavBakeError`.
+ */
+export interface NavBakeOptions {
+    /** World units per heightfield cell across (XZ), > 0. The level's smallest feature should span a few. */
+    cellSize: number;
+    /** World units per heightfield cell up (Y), > 0. Default `cellSize / 2`. */
+    cellHeight?: number;
+    /** The agent's height, > 0: a ceiling closer than this to the floor is not walkable. Default 2. */
+    agentHeight?: number;
+    /** The agent's radius, >= 0: the walkable area is eroded by it, so the centre never leaves the floor. Default `cellSize * 2`. */
+    agentRadius?: number;
+    /** The largest step the agent climbs (a kerb), >= 0; a taller drop is a ledge. Default `cellHeight * 2`. */
+    agentMaxClimb?: number;
+    /** The steepest walkable slope, in degrees from flat, 0..90. Default 45. */
+    agentMaxSlope?: number;
+    /** Regions (connected walkable islands) smaller than this many cells are dropped, >= 0. Default 8. */
+    minRegionArea?: number;
+    /** Regions smaller than this many cells merge into a neighbour where that keeps it hole-free, >= 0. Default 20. */
+    mergeRegionArea?: number;
+    /** Boundary edges longer than this (world units, >= 0) are split. Default 12 × `cellSize`; 0 never splits. */
+    maxEdgeLength?: number;
+    /** How far (world units, >= 0) a simplified contour may stray from the rasterised one. Default 1.3 × `cellSize`. */
+    maxSimplification?: number;
+    /** Vertices per polygon at most, an integer 3..6. Default 6. */
+    maxVertsPerPoly?: number;
+}
+export declare const NULL_AREA = 0;
+export declare const WALKABLE_AREA = 1;
+export declare const NOT_CONNECTED = -1;
+/** Neighbour offsets by direction: 0 = -x, 1 = +z, 2 = +x, 3 = -z. */
+export declare const DIR_X: readonly [-1, 0, 1, 0];
+export declare const DIR_Z: readonly [0, 1, 0, -1];
+export interface Heightfield {
+    width: number;
+    height: number;
+    bmin: [number, number, number];
+    bmax: [number, number, number];
+    cs: number;
+    ch: number;
+    /** First span of each column (`x + z * width`), or -1. */
+    first: Int32Array;
+    smin: Int32Array;
+    smax: Int32Array;
+    area: Uint8Array;
+    next: Int32Array;
+    /** Spans allocated so far (the pool's high-water mark). */
+    count: number;
+    /** Head of the free list of span slots, or -1. */
+    free: number;
+}
+export interface CompactHeightfield {
+    width: number;
+    height: number;
+    spanCount: number;
+    walkableHeight: number;
+    walkableClimb: number;
+    bmin: [number, number, number];
+    bmax: [number, number, number];
+    cs: number;
+    ch: number;
+    /** First span and span count of each column. */
+    cellIndex: Int32Array;
+    cellCount: Int32Array;
+    /** Per span: floor height (cells), free height above it, area, region. */
+    y: Int32Array;
+    h: Int32Array;
+    areas: Uint8Array;
+    regs: Uint16Array;
+    /** Per span × 4 directions: the neighbour span index, or `NOT_CONNECTED`. */
+    con: Int32Array;
+    maxRegions: number;
+}
+export declare function computeBounds(sources: readonly NavBakeSource[], outMin: number[], outMax: number[]): boolean;
+export declare function createHeightfield(width: number, height: number, bmin: readonly number[], bmax: readonly number[], cs: number, ch: number): Heightfield;
+/** Adds a span to a column, merging the spans it overlaps (Recast `rcAddSpan`). */
+export declare function addSpan(hf: Heightfield, x: number, z: number, smin: number, smax: number, area: number, flagMergeThr: number): void;
+/** Rasterises one triangle (world coordinates) into the heightfield. */
+export declare function rasterizeTriangle(hf: Heightfield, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, area: number, flagMergeThr: number): void;
+/**
+ * Rasterises every triangle of every source. A triangle whose normal is steeper than
+ * `maxSlopeDeg` from +y is rasterised as an obstacle (`NULL_AREA`) so it blocks; others as
+ * walkable floor.
+ */
+export declare function rasterizeSources(hf: Heightfield, sources: readonly NavBakeSource[], maxSlopeDeg: number, flagMergeThr: number): number;
+/** A blocking span resting on a walkable one, no higher than a step, becomes walkable (a kerb). */
+export declare function filterLowHangingWalkableObstacles(hf: Heightfield, walkableClimb: number): void;
+/** A span whose drop to a neighbour exceeds the climb, or whose neighbours differ too much in height, is a ledge. */
+export declare function filterLedgeSpans(hf: Heightfield, walkableHeight: number, walkableClimb: number): void;
+/** A span with less than the agent's height of free space above it is not walkable. */
+export declare function filterWalkableLowHeightSpans(hf: Heightfield, walkableHeight: number): void;
+/** One record per walkable span, with its four neighbour connections. */
+export declare function buildCompactHeightfield(hf: Heightfield, walkableHeight: number, walkableClimb: number): CompactHeightfield;
+/** Marks every walkable span within `radius` cells of a boundary unwalkable (Recast `rcErodeWalkableArea`). */
+export declare function erodeWalkableArea(chf: CompactHeightfield, radius: number): void;