@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/libraries/navmesh/src/navmesh-generator.js

@@ -0,0 +1,364 @@
+export class NavMeshGenerator {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    generate(sampler, minX, minZ, maxX, maxZ) {
+        const cells = this.voxelize(sampler, minX, minZ, maxX, maxZ);
+        this.partitionRegions(cells);
+        const { polygons, vertices, vertexCount } = this.buildCellPolygons(cells, minX, minZ);
+        const polysWithPortals = this.detectPortals(polygons, vertices);
+        this.computeCentroidsAndArea(polysWithPortals, vertices);
+        return {
+            polygons: polysWithPortals,
+            vertices,
+            vertexCount,
+        };
+    }
+    voxelize(sampler, minX, minZ, maxX, maxZ) {
+        const cs = this.config.cellSize;
+        const cols = Math.ceil((maxX - minX) / cs);
+        const rows = Math.ceil((maxZ - minZ) / cs);
+        const grid = [];
+        for (let z = 0; z < rows; z++) {
+            grid[z] = [];
+            for (let x = 0; x < cols; x++) {
+                const wx = minX + x * cs;
+                const wz = minZ + z * cs;
+                if (sampler.isWalkable(wx, wz)) {
+                    const h = sampler.sampleHeight(wx, wz);
+                    grid[z][x] = { x, z, height: h, region: -1, walkable: true };
+                }
+                else {
+                    grid[z][x] = { x, z, height: 0, region: -1, walkable: false };
+                }
+            }
+        }
+        return grid;
+    }
+    partitionRegions(cells) {
+        let nextRegion = 0;
+        const rows = cells.length;
+        const cols = rows > 0 ? cells[0].length : 0;
+        const minSize = this.config.regionMinSize;
+        const visited = Array.from({ length: rows }, () => new Array(cols).fill(false));
+        for (let z = 0; z < rows; z++) {
+            for (let x = 0; x < cols; x++) {
+                if (!cells[z][x].walkable)
+                    visited[z][x] = true;
+            }
+        }
+        for (let z = 0; z < rows; z++) {
+            for (let x = 0; x < cols; x++) {
+                if (visited[z][x] || !cells[z][x].walkable || cells[z][x].region >= 0)
+                    continue;
+                const flood = [];
+                const queue = [[x, z]];
+                visited[z][x] = true;
+                while (queue.length > 0) {
+                    const [cx, cz] = queue.shift();
+                    const cell = cells[cz][cx];
+                    if (cell.region >= 0)
+                        continue;
+                    cell.region = nextRegion;
+                    flood.push(cell);
+                    const neighbors = [
+                        [cx + 1, cz], [cx - 1, cz],
+                        [cx, cz + 1], [cx, cz - 1],
+                    ];
+                    for (let _i = 0, _it = neighbors, _n = _it.length; _i < _n; _i++) {
+                        const [nx, nz] = _it[_i];
+                        if (nx < 0 || nx >= cols || nz < 0 || nz >= rows)
+                            continue;
+                        if (visited[nz][nx])
+                            continue;
+                        const nc = cells[nz][nx];
+                        if (!nc.walkable || nc.region >= 0)
+                            continue;
+                        const heightDiff = Math.abs(nc.height - cell.height);
+                        if (heightDiff > this.config.maxStep)
+                            continue;
+                        visited[nz][nx] = true;
+                        queue.push([nx, nz]);
+                    }
+                }
+                if (flood.length < minSize) {
+                    flood.forEach((c) => {
+                        c.region = -1;
+                    });
+                }
+                else {
+                    nextRegion++;
+                }
+            }
+        }
+        return nextRegion;
+    }
+    extractContours(cells, _regionCount) {
+        const rows = cells.length;
+        const cols = rows > 0 ? cells[0].length : 0;
+        const cs = this.config.cellSize;
+        const contours = new Map();
+        const regionEdges = new Map();
+        for (let z = 0; z < rows; z++) {
+            for (let x = 0; x < cols; x++) {
+                const cell = cells[z][x];
+                if (cell.region < 0)
+                    continue;
+                const h = cell.height;
+                const wx = x * cs;
+                const wz = z * cs;
+                const corners = [
+                    [wx, h, wz],
+                    [wx + cs, h, wz],
+                    [wx + cs, h, wz + cs],
+                    [wx, h, wz + cs],
+                ];
+                const neighbors = [
+                    [x, z - 1], [x + 1, z], [x, z + 1], [x - 1, z],
+                ];
+                for (let d = 0; d < 4; d++) {
+                    const [nx, nz] = neighbors[d];
+                    const isBoundary = nx < 0 || nx >= cols || nz < 0 || nz >= rows || cells[nz][nx].region !== cell.region;
+                    if (!isBoundary)
+                        continue;
+                    if (!regionEdges.has(cell.region)) {
+                        regionEdges.set(cell.region, []);
+                    }
+                    const edges = regionEdges.get(cell.region);
+                    const v0 = corners[d];
+                    const v1 = corners[(d + 1) % 4];
+                    edges.push([v0, v1]);
+                }
+            }
+        }
+        for (const [region, edges] of regionEdges.entries()) {
+            const contour = this.chainEdges(edges);
+            if (contour.length >= 3) {
+                contours.set(region, this.simplifyContour(contour));
+            }
+        }
+        return contours;
+    }
+    chainEdges(edges) {
+        if (edges.length === 0)
+            return [];
+        const used = new Array(edges.length).fill(false);
+        const contour = [edges[0][0]];
+        let current = edges[0][1];
+        contour.push(current);
+        used[0] = true;
+        let count = 1;
+        while (count < edges.length) {
+            let found = false;
+            for (let i = 0; i < edges.length; i++) {
+                if (used[i])
+                    continue;
+                if (this.vecClose(edges[i][0], current)) {
+                    current = edges[i][1];
+                    used[i] = true;
+                    count++;
+                    found = true;
+                    break;
+                }
+                if (this.vecClose(edges[i][1], current)) {
+                    current = edges[i][0];
+                    used[i] = true;
+                    count++;
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
+                break;
+            if (!this.vecClose(current, contour[0])) {
+                contour.push(current);
+            }
+        }
+        if (contour.length > 1 && this.vecClose(contour[contour.length - 1], contour[0])) {
+            contour.pop();
+        }
+        return contour;
+    }
+    vecClose(a, b) {
+        const eps = 0.001;
+        return Math.abs(a[0] - b[0]) < eps && Math.abs(a[2] - b[2]) < eps;
+    }
+    simplifyContour(contour, epsilon = 0.1) {
+        if (contour.length <= 3)
+            return contour;
+        const result = [contour[0]];
+        for (let i = 1; i < contour.length - 1; i++) {
+            const prev = result[result.length - 1];
+            const curr = contour[i];
+            const next = contour[i + 1];
+            const dx1 = curr[0] - prev[0];
+            const dz1 = curr[2] - prev[2];
+            const dx2 = next[0] - curr[0];
+            const dz2 = next[2] - curr[2];
+            const cross = dx1 * dz2 - dz1 * dx2;
+            const len1 = Math.sqrt(dx1 * dx1 + dz1 * dz1);
+            const len2 = Math.sqrt(dx2 * dx2 + dz2 * dz2);
+            if (len1 < epsilon || len2 < epsilon)
+                continue;
+            const angle = Math.abs(Math.atan2(cross, dx1 * dx2 + dz1 * dz2));
+            if (angle > 0.05) {
+                result.push(curr);
+            }
+        }
+        result.push(contour[contour.length - 1]);
+        return result;
+    }
+    buildCellPolygons(cells, originX, originZ) {
+        const cs = this.config.cellSize;
+        const rows = cells.length;
+        const cols = rows > 0 ? cells[0].length : 0;
+        const vertexList = [];
+        const vertexMap = new Map();
+        const polygons = [];
+        const polyGrid = Array.from({ length: rows }, () => new Array(cols).fill(-1));
+        for (let z = 0; z < rows; z++) {
+            for (let x = 0; x < cols; x++) {
+                const cell = cells[z][x];
+                if (cell.region < 0 || !cell.walkable)
+                    continue;
+                const h = cell.height;
+                const wx = originX + x * cs;
+                const wz = originZ + z * cs;
+                const corners = [
+                    [wx, h, wz],
+                    [wx + cs, h, wz],
+                    [wx + cs, h, wz + cs],
+                    [wx, h, wz + cs],
+                ];
+                const vertexIndices = [];
+                corners.forEach((v) => {
+                    const key = `${v[0].toFixed(3)}:${v[1].toFixed(3)}:${v[2].toFixed(3)}`;
+                    let idx = vertexMap.get(key);
+                    if (idx === undefined) {
+                        idx = vertexList.length / 3;
+                        vertexList.push(v[0], v[1], v[2]);
+                        vertexMap.set(key, idx);
+                    }
+                    vertexIndices.push(idx);
+                });
+                const polyId = polygons.length;
+                polyGrid[z][x] = polyId;
+                polygons.push({
+                    id: polyId,
+                    vertexIndices,
+                    neighborPolys: [],
+                    portalEdges: [],
+                    centroid: [0, 0, 0],
+                    area: 0,
+                    region: cell.region,
+                });
+            }
+        }
+        for (let z = 0; z < rows; z++) {
+            for (let x = 0; x < cols; x++) {
+                const polyId = polyGrid[z][x];
+                if (polyId < 0)
+                    continue;
+                const neighbors = [[x + 1, z], [x, z + 1]];
+                for (let _i = 0, _it = neighbors, _n = _it.length; _i < _n; _i++) {
+                    const [nx, nz] = _it[_i];
+                    if (nx >= cols || nz >= rows)
+                        continue;
+                    const neighborId = polyGrid[nz][nx];
+                    if (neighborId < 0)
+                        continue;
+                    polygons[polyId].neighborPolys.push(neighborId);
+                    polygons[neighborId].neighborPolys.push(polyId);
+                }
+            }
+        }
+        const vertices = new Float32Array(vertexList);
+        return { polygons, vertices, vertexCount: vertexList.length / 3 };
+    }
+    detectPortals(polygons, vertices) {
+        for (let i = 0; i < polygons.length; i++) {
+            for (let _i = 0, _it = polygons[i].neighborPolys, _n = _it.length; _i < _n; _i++) {
+                const j = _it[_i];
+                if (j <= i)
+                    continue;
+                const shared = this.findSharedEdge(polygons[i], polygons[j], vertices);
+                if (shared) {
+                    const portal = {
+                        fromPoly: i,
+                        toPoly: j,
+                        left: shared[0],
+                        right: shared[1],
+                    };
+                    polygons[i].portalEdges.push(portal);
+                    const reversePortal = {
+                        fromPoly: j,
+                        toPoly: i,
+                        left: shared[1],
+                        right: shared[0],
+                    };
+                    polygons[j].portalEdges.push(reversePortal);
+                }
+            }
+        }
+        return polygons;
+    }
+    findSharedEdge(a, b, vertices) {
+        const vertsA = a.vertexIndices;
+        const vertsB = b.vertexIndices;
+        for (let i = 0; i < vertsA.length; i++) {
+            const ai1 = vertsA[i];
+            const ai2 = vertsA[(i + 1) % vertsA.length];
+            for (let j = 0; j < vertsB.length; j++) {
+                const bj1 = vertsB[j];
+                const bj2 = vertsB[(j + 1) % vertsB.length];
+                if (this.vertexEqual(ai1, bj2, vertices) && this.vertexEqual(ai2, bj1, vertices)) {
+                    return [
+                        [vertices[ai1 * 3], vertices[ai1 * 3 + 1], vertices[ai1 * 3 + 2]],
+                        [vertices[ai2 * 3], vertices[ai2 * 3 + 1], vertices[ai2 * 3 + 2]],
+                    ];
+                }
+            }
+        }
+        return null;
+    }
+    vertexEqual(a, b, vertices) {
+        const eps = 0.001;
+        return Math.abs(vertices[a * 3] - vertices[b * 3]) < eps &&
+            Math.abs(vertices[a * 3 + 1] - vertices[b * 3 + 1]) < eps &&
+            Math.abs(vertices[a * 3 + 2] - vertices[b * 3 + 2]) < eps;
+    }
+    computeCentroidsAndArea(polygons, vertices) {
+        polygons.forEach((poly) => {
+            let cx = 0, cy = 0, cz = 0;
+            let area = 0;
+            const verts = poly.vertexIndices;
+            const n = verts.length;
+            for (let i = 0; i < n; i++) {
+                const vi = verts[i];
+                const vj = verts[(i + 1) % n];
+                const xi = vertices[vi * 3];
+                const zi = vertices[vi * 3 + 2];
+                const xj = vertices[vj * 3];
+                const zj = vertices[vj * 3 + 2];
+                const cross = xi * zj - xj * zi;
+                area += cross;
+                cx += (xi + xj) * cross;
+                cz += (zi + zj) * cross;
+                cy += vertices[vi * 3 + 1];
+            }
+            area = Math.abs(area) * 0.5;
+            if (area > 0.0001) {
+                poly.centroid = [cx / (6 * area), cy / n, cz / (6 * area)];
+            }
+            else {
+                for (let i = 0; i < n; i++) {
+                    cx += vertices[verts[i] * 3];
+                    cz += vertices[verts[i] * 3 + 2];
+                }
+                poly.centroid = [cx / n, cy / n, cz / n];
+            }
+            poly.area = area;
+        });
+    }
+}

package/dist/libraries/navmesh/src/navmesh.js

@@ -0,0 +1,141 @@
+export class NavMesh {
+    polygons = [];
+    vertices = new Float32Array(0);
+    vertexCount = 0;
+    spatialGrid = new Map();
+    spatialCellSize;
+    constructor(spatialCellSize = 4) {
+        this.spatialCellSize = spatialCellSize;
+    }
+    build(data) {
+        this.polygons = data.polygons;
+        this.vertices = data.vertices;
+        this.vertexCount = data.vertexCount;
+        this.rebuildSpatialIndex();
+    }
+    clear() {
+        this.polygons = [];
+        this.vertices = new Float32Array(0);
+        this.vertexCount = 0;
+        this.spatialGrid.clear();
+    }
+    getPolyCount() {
+        return this.polygons.length;
+    }
+    findClosestPoly(point) {
+        let bestPoly = -1;
+        let bestDistSq = Infinity;
+        const candidates = this.getPolysInRadius(point, this.spatialCellSize * 2);
+        for (let _i = 0, _it = candidates, _n = _it.length; _i < _n; _i++) {
+            const polyId = _it[_i];
+            if (this.isPointInPoly(polyId, point)) {
+                return polyId;
+            }
+            const center = this.polygons[polyId].centroid;
+            const dx = center[0] - point[0];
+            const dy = center[1] - point[1];
+            const dz = center[2] - point[2];
+            const distSq = dx * dx + dy * dy + dz * dz;
+            if (distSq < bestDistSq) {
+                bestDistSq = distSq;
+                bestPoly = polyId;
+            }
+        }
+        if (bestPoly >= 0)
+            return bestPoly;
+        for (let i = 0; i < this.polygons.length; i++) {
+            const center = this.polygons[i].centroid;
+            const dx = center[0] - point[0];
+            const dy = center[1] - point[1];
+            const dz = center[2] - point[2];
+            const distSq = dx * dx + dy * dy + dz * dz;
+            if (distSq < bestDistSq) {
+                bestDistSq = distSq;
+                bestPoly = i;
+            }
+        }
+        return bestPoly;
+    }
+    getPolyCenter(polyId) {
+        return this.polygons[polyId].centroid;
+    }
+    getPolyNeighbors(polyId) {
+        return this.polygons[polyId].neighborPolys;
+    }
+    isPointInPoly(polyId, point) {
+        const poly = this.polygons[polyId];
+        if (!poly)
+            return false;
+        const verts = poly.vertexIndices;
+        let inside = false;
+        for (let i = 0, j = verts.length - 1; i < verts.length; j = i++) {
+            const vi = verts[i];
+            const vj = verts[j];
+            const xi = this.vertices[vi * 3];
+            const zi = this.vertices[vi * 3 + 2];
+            const xj = this.vertices[vj * 3];
+            const zj = this.vertices[vj * 3 + 2];
+            if (((zi > point[2]) !== (zj > point[2])) &&
+                (point[0] < (xj - xi) * (point[2] - zi) / (zj - zi) + xi)) {
+                inside = !inside;
+            }
+        }
+        return inside;
+    }
+    getPortalEdge(fromPoly, toPoly) {
+        const poly = this.polygons[fromPoly];
+        if (!poly)
+            return null;
+        for (let _i = 0, _it = poly.portalEdges, _n = _it.length; _i < _n; _i++) {
+            const pe = _it[_i];
+            if (pe.toPoly === toPoly)
+                return pe;
+        }
+        return null;
+    }
+    getVertex(index) {
+        return [
+            this.vertices[index * 3],
+            this.vertices[index * 3 + 1],
+            this.vertices[index * 3 + 2],
+        ];
+    }
+    getPolysInRadius(center, radius) {
+        const minCx = Math.floor((center[0] - radius) / this.spatialCellSize);
+        const maxCx = Math.floor((center[0] + radius) / this.spatialCellSize);
+        const minCz = Math.floor((center[2] - radius) / this.spatialCellSize);
+        const maxCz = Math.floor((center[2] + radius) / this.spatialCellSize);
+        const result = [];
+        const seen = new Set();
+        for (let cx = minCx; cx <= maxCx; cx++) {
+            for (let cz = minCz; cz <= maxCz; cz++) {
+                const cell = this.spatialGrid.get(`${cx}:${cz}`);
+                if (!cell)
+                    continue;
+                cell.polys.forEach((pid) => {
+                    if (!seen.has(pid)) {
+                        seen.add(pid);
+                        result.push(pid);
+                    }
+                });
+            }
+        }
+        return result;
+    }
+    rebuildSpatialIndex() {
+        this.spatialGrid.clear();
+        for (let i = 0; i < this.polygons.length; i++) {
+            const poly = this.polygons[i];
+            const c = poly.centroid;
+            const cx = Math.floor(c[0] / this.spatialCellSize);
+            const cz = Math.floor(c[2] / this.spatialCellSize);
+            const key = `${cx}:${cz}`;
+            let cell = this.spatialGrid.get(key);
+            if (!cell) {
+                cell = { polys: [] };
+                this.spatialGrid.set(key, cell);
+            }
+            cell.polys.push(i);
+        }
+    }
+}