@manycore/aholo-splat-transform 1.2.7 → 1.2.9

package/dist/utils/voxel/mesh.d.ts

@@ -1,3 +1,3 @@
-import { SparseVoxelGrid, type Bounds } from './common.js';
-export type CollisionMeshShape = 'smooth' | 'faces';
-export declare const buildCollisionMesh: (grid: SparseVoxelGrid, gridBounds: Bounds, voxelResolution: number, shape?: CollisionMeshShape) => Uint8Array | undefined;
+import type { SparseVoxelGrid, Bounds } from './common.js';
+export type CollisionMeshShape = 'smooth' | 'faces';
+export declare function buildCollisionMesh(grid: SparseVoxelGrid, gridBounds: Bounds, voxelResolution: number, shape?: CollisionMeshShape): Uint8Array | undefined;

package/dist/utils/voxel/mesh.js

@@ -1,130 +1,130 @@
-import { coplanarMerge } from './coplanar-merge.js';
-import { marchingCubes } from './marching-cubes.js';
-import { voxelFaces } from './voxel-faces.js';
-import { logger } from '../Logger.js';
-const encodeGlb = (positions, indices) => {
-    const vertexCount = positions.length / 3;
-    const indexCount = indices.length;
-    let minX = Infinity, minY = Infinity, minZ = Infinity;
-    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-    for (let i = 0; i < positions.length; i += 3) {
-        const x = positions[i];
-        const y = positions[i + 1];
-        const z = positions[i + 2];
-        if (x < minX) {
-            minX = x;
-        }
-        if (y < minY) {
-            minY = y;
-        }
-        if (z < minZ) {
-            minZ = z;
-        }
-        if (x > maxX) {
-            maxX = x;
-        }
-        if (y > maxY) {
-            maxY = y;
-        }
-        if (z > maxZ) {
-            maxZ = z;
-        }
-    }
-    const positionsByteLength = positions.byteLength;
-    const indicesByteLength = indices.byteLength;
-    const totalBinSize = positionsByteLength + indicesByteLength;
-    const gltf = {
-        asset: { version: '2.0', generator: 'splat-transform' },
-        scene: 0,
-        scenes: [{ nodes: [0] }],
-        nodes: [{ mesh: 0 }],
-        meshes: [{ primitives: [{ attributes: { POSITION: 0 }, indices: 1 }] }],
-        accessors: [
-            {
-                bufferView: 0,
-                componentType: 5126,
-                count: vertexCount,
-                type: 'VEC3',
-                min: [minX, minY, minZ],
-                max: [maxX, maxY, maxZ]
-            },
-            {
-                bufferView: 1,
-                componentType: 5125,
-                count: indexCount,
-                type: 'SCALAR'
-            }
-        ],
-        bufferViews: [
-            { buffer: 0, byteOffset: 0, byteLength: positionsByteLength, target: 34962 },
-            { buffer: 0, byteOffset: positionsByteLength, byteLength: indicesByteLength, target: 34963 }
-        ],
-        buffers: [{ byteLength: totalBinSize }]
-    };
-    const jsonBytes = new TextEncoder().encode(JSON.stringify(gltf));
-    const jsonPadding = (4 - (jsonBytes.length % 4)) % 4;
-    const jsonChunkLength = jsonBytes.length + jsonPadding;
-    const binPadding = (4 - (totalBinSize % 4)) % 4;
-    const binChunkLength = totalBinSize + binPadding;
-    const totalLength = 12 + 8 + jsonChunkLength + 8 + binChunkLength;
-    const buffer = new ArrayBuffer(totalLength);
-    const view = new DataView(buffer);
-    const bytes = new Uint8Array(buffer);
-    let offset = 0;
-    view.setUint32(offset, 0x46546C67, true);
-    offset += 4;
-    view.setUint32(offset, 2, true);
-    offset += 4;
-    view.setUint32(offset, totalLength, true);
-    offset += 4;
-    view.setUint32(offset, jsonChunkLength, true);
-    offset += 4;
-    view.setUint32(offset, 0x4E4F534A, true);
-    offset += 4;
-    bytes.set(jsonBytes, offset);
-    offset += jsonBytes.length;
-    for (let i = 0; i < jsonPadding; i++) {
-        bytes[offset++] = 0x20;
-    }
-    view.setUint32(offset, binChunkLength, true);
-    offset += 4;
-    view.setUint32(offset, 0x004E4942, true);
-    offset += 4;
-    bytes.set(new Uint8Array(positions.buffer, positions.byteOffset, positionsByteLength), offset);
-    offset += positionsByteLength;
-    bytes.set(new Uint8Array(indices.buffer, indices.byteOffset, indicesByteLength), offset);
-    return bytes;
-};
-export const buildCollisionMesh = (grid, gridBounds, voxelResolution, shape = 'smooth') => {
-    const nx = Math.round((gridBounds.max.x - gridBounds.min.x) / voxelResolution);
-    const ny = Math.round((gridBounds.max.y - gridBounds.min.y) / voxelResolution);
-    const nz = Math.round((gridBounds.max.z - gridBounds.min.z) / voxelResolution);
-    if (nx % 4 !== 0 || ny % 4 !== 0 || nz % 4 !== 0) {
-        return undefined;
-    }
-    logger.time('Build collision mesh');
-    let mesh;
-    if (shape === 'faces') {
-        mesh = voxelFaces(grid, gridBounds, voxelResolution);
-        logger.info(`collision mesh faces: ${mesh.positions.length / 3} vertices, ${mesh.indices.length / 3} triangles`);
-    }
-    else {
-        const preMerged = marchingCubes(grid, gridBounds, voxelResolution, { mergeFlatFaces: true });
-        logger.info(`collision mesh pre-merged: ${preMerged.positions.length / 3} vertices, ${preMerged.indices.length / 3} triangles`);
-        if (preMerged.indices.length < 3) {
-            mesh = preMerged;
-        }
-        else {
-            mesh = coplanarMerge(preMerged, voxelResolution);
-            const reduction = (1 - mesh.indices.length / preMerged.indices.length) * 100;
-            logger.info(`collision mesh merged: ${mesh.positions.length / 3} vertices, ${mesh.indices.length / 3} triangles`);
-            logger.info(`collision mesh reduction: ${reduction.toFixed(0)}%`);
-        }
-    }
-    logger.timeEnd('Build collision mesh');
-    if (mesh.indices.length < 3) {
-        logger.warn('collision mesh: no triangles generated, skipping GLB output');
-        return undefined;
-    }
-    return encodeGlb(mesh.positions, mesh.indices);
-};
+import { coplanarMerge } from './coplanar-merge.js';
+import { marchingCubes } from './marching-cubes.js';
+import { voxelFaces } from './voxel-faces.js';
+import { logger } from '../Logger.js';
+function encodeGlb(positions, indices) {
+    const vertexCount = positions.length / 3;
+    const indexCount = indices.length;
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    for (let i = 0; i < positions.length; i += 3) {
+        const x = positions[i];
+        const y = positions[i + 1];
+        const z = positions[i + 2];
+        if (x < minX) {
+            minX = x;
+        }
+        if (y < minY) {
+            minY = y;
+        }
+        if (z < minZ) {
+            minZ = z;
+        }
+        if (x > maxX) {
+            maxX = x;
+        }
+        if (y > maxY) {
+            maxY = y;
+        }
+        if (z > maxZ) {
+            maxZ = z;
+        }
+    }
+    const positionsByteLength = positions.byteLength;
+    const indicesByteLength = indices.byteLength;
+    const totalBinSize = positionsByteLength + indicesByteLength;
+    const gltf = {
+        asset: { version: '2.0', generator: 'splat-transform' },
+        scene: 0,
+        scenes: [{ nodes: [0] }],
+        nodes: [{ mesh: 0 }],
+        meshes: [{ primitives: [{ attributes: { POSITION: 0 }, indices: 1 }] }],
+        accessors: [
+            {
+                bufferView: 0,
+                componentType: 5126,
+                count: vertexCount,
+                type: 'VEC3',
+                min: [minX, minY, minZ],
+                max: [maxX, maxY, maxZ],
+            },
+            {
+                bufferView: 1,
+                componentType: 5125,
+                count: indexCount,
+                type: 'SCALAR',
+            },
+        ],
+        bufferViews: [
+            { buffer: 0, byteOffset: 0, byteLength: positionsByteLength, target: 34962 },
+            { buffer: 0, byteOffset: positionsByteLength, byteLength: indicesByteLength, target: 34963 },
+        ],
+        buffers: [{ byteLength: totalBinSize }],
+    };
+    const jsonBytes = new TextEncoder().encode(JSON.stringify(gltf));
+    const jsonPadding = (4 - (jsonBytes.length % 4)) % 4;
+    const jsonChunkLength = jsonBytes.length + jsonPadding;
+    const binPadding = (4 - (totalBinSize % 4)) % 4;
+    const binChunkLength = totalBinSize + binPadding;
+    const totalLength = 12 + 8 + jsonChunkLength + 8 + binChunkLength;
+    const buffer = new ArrayBuffer(totalLength);
+    const view = new DataView(buffer);
+    const bytes = new Uint8Array(buffer);
+    let offset = 0;
+    view.setUint32(offset, 0x46546c67, true);
+    offset += 4;
+    view.setUint32(offset, 2, true);
+    offset += 4;
+    view.setUint32(offset, totalLength, true);
+    offset += 4;
+    view.setUint32(offset, jsonChunkLength, true);
+    offset += 4;
+    view.setUint32(offset, 0x4e4f534a, true);
+    offset += 4;
+    bytes.set(jsonBytes, offset);
+    offset += jsonBytes.length;
+    for (let i = 0; i < jsonPadding; i++) {
+        bytes[offset++] = 0x20;
+    }
+    view.setUint32(offset, binChunkLength, true);
+    offset += 4;
+    view.setUint32(offset, 0x004e4942, true);
+    offset += 4;
+    bytes.set(new Uint8Array(positions.buffer, positions.byteOffset, positionsByteLength), offset);
+    offset += positionsByteLength;
+    bytes.set(new Uint8Array(indices.buffer, indices.byteOffset, indicesByteLength), offset);
+    return bytes;
+}
+export function buildCollisionMesh(grid, gridBounds, voxelResolution, shape = 'smooth') {
+    const nx = Math.round((gridBounds.max.x - gridBounds.min.x) / voxelResolution);
+    const ny = Math.round((gridBounds.max.y - gridBounds.min.y) / voxelResolution);
+    const nz = Math.round((gridBounds.max.z - gridBounds.min.z) / voxelResolution);
+    if (nx % 4 !== 0 || ny % 4 !== 0 || nz % 4 !== 0) {
+        return undefined;
+    }
+    logger.time('Build collision mesh');
+    let mesh;
+    if (shape === 'faces') {
+        mesh = voxelFaces(grid, gridBounds, voxelResolution);
+        logger.info(`collision mesh faces: ${mesh.positions.length / 3} vertices, ${mesh.indices.length / 3} triangles`);
+    }
+    else {
+        const preMerged = marchingCubes(grid, gridBounds, voxelResolution, { mergeFlatFaces: true });
+        logger.info(`collision mesh pre-merged: ${preMerged.positions.length / 3} vertices, ${preMerged.indices.length / 3} triangles`);
+        if (preMerged.indices.length < 3) {
+            mesh = preMerged;
+        }
+        else {
+            mesh = coplanarMerge(preMerged, voxelResolution);
+            const reduction = (1 - mesh.indices.length / preMerged.indices.length) * 100;
+            logger.info(`collision mesh merged: ${mesh.positions.length / 3} vertices, ${mesh.indices.length / 3} triangles`);
+            logger.info(`collision mesh reduction: ${reduction.toFixed(0)}%`);
+        }
+    }
+    logger.timeEnd('Build collision mesh');
+    if (mesh.indices.length < 3) {
+        logger.warn('collision mesh: no triangles generated, skipping GLB output');
+        return undefined;
+    }
+    return encodeGlb(mesh.positions, mesh.indices);
+}

package/dist/utils/voxel/nav.d.ts

@@ -1,29 +1,29 @@
-import { SparseVoxelGrid, type Bounds } from './common.js';
-interface NavSeed {
-    x: number;
-    y: number;
-    z: number;
-}
-type VoxelBackend = 'cpu' | 'gpu';
-interface VoxelNavResult {
-    grid: SparseVoxelGrid;
-    gridBounds: Bounds;
-}
-/**
- * Fill exterior-reachable space from boundary seeds and merge it back into
- * occupancy after dilation. Returns cropped bounds around navigable volume.
- */
-export declare function fillExterior(gridOriginal: SparseVoxelGrid, gridBounds: Bounds, voxelResolution: number, dilation: number, seed: NavSeed, backend?: VoxelBackend): Promise<VoxelNavResult>;
-/**
- * Carve navigable space for a capsule by:
- * 1) dilating blocked voxels by capsule dimensions
- * 2) flood filling reachable empty space from the seed
- * 3) dilating and inverting to final occupancy representation.
- */
-export declare function carve(grid: SparseVoxelGrid, gridBounds: Bounds, voxelResolution: number, capsuleHeight: number, capsuleRadius: number, seed: NavSeed, backend?: VoxelBackend): Promise<VoxelNavResult>;
-/**
- * Floor-fill via XZ dilate -> per-column upward walk -> XZ dilate -> OR.
- * This mirrors upstream's block/bitmask walk instead of per-voxel getVoxel checks.
- */
-export declare function fillFloor(gridOriginal: SparseVoxelGrid, gridBounds: Bounds, voxelResolution: number, dilation?: number, backend?: VoxelBackend): Promise<VoxelNavResult>;
-export type { NavSeed, Bounds };
+import { SparseVoxelGrid, type Bounds } from './common.js';
+interface NavSeed {
+    x: number;
+    y: number;
+    z: number;
+}
+type VoxelBackend = 'cpu' | 'gpu';
+interface VoxelNavResult {
+    grid: SparseVoxelGrid;
+    gridBounds: Bounds;
+}
+/**
+ * Fill exterior-reachable space from boundary seeds and merge it back into
+ * occupancy after dilation. Returns cropped bounds around navigable volume.
+ */
+export declare function fillExterior(gridOriginal: SparseVoxelGrid, gridBounds: Bounds, voxelResolution: number, dilation: number, seed: NavSeed, backend?: VoxelBackend): Promise<VoxelNavResult>;
+/**
+ * Carve navigable space for a capsule by:
+ * 1) dilating blocked voxels by capsule dimensions
+ * 2) flood filling reachable empty space from the seed
+ * 3) dilating and inverting to final occupancy representation.
+ */
+export declare function carve(grid: SparseVoxelGrid, gridBounds: Bounds, voxelResolution: number, capsuleHeight: number, capsuleRadius: number, seed: NavSeed, backend?: VoxelBackend): Promise<VoxelNavResult>;
+/**
+ * Floor-fill via XZ dilate -> per-column upward walk -> XZ dilate -> OR.
+ * This mirrors upstream's block/bitmask walk instead of per-voxel getVoxel checks.
+ */
+export declare function fillFloor(gridOriginal: SparseVoxelGrid, gridBounds: Bounds, voxelResolution: number, dilation?: number, backend?: VoxelBackend): Promise<VoxelNavResult>;
+export type { NavSeed, Bounds };