@playcanvas/splat-transform 2.0.4 → 2.0.6

package/dist/index.mjs

@@ -6275,11 +6275,11 @@ class CompressedChunk {
 /**
  * The splat-transform version (semver MAJOR.MINOR.PATCH).
  */
-const version = '2.0.4';
+const version = '2.0.6';
 /**
  * The splat-transform revision (short Git hash of HEAD at build time).
  */
-const revision = 'fa46db3';
+const revision = 'aa3dbae';
 
 const generatedByString = `Generated by splat-transform ${version}`;
 const chunkProps = [
@@ -8267,13 +8267,17 @@ class GpuDilation {
         // Extract: clear bufferA, dispatch extract from sparse src into bufferA.
         this.dispatchClear(slot, slot.bufferA, numWords);
         this.dispatchExtract(slot, minBx, minBy, minBz, outerBx, outerBy, outerBz, numXWords);
-        // Tiny throwaway readback forces a queue submit between extract
-        // and dilate. WITHOUT this, atomicOr writes from the extract pass
-        // aren't reliably visible to the next dilate pass (apparent
-        // missing memory barrier in PlayCanvas/Dawn for cross-pass atomic
-        // writes). Promise is intentionally not awaited — only the
-        // implicit submit+barrier matters. 16 bytes ≈ negligible PCIe.
-        slot.bufferA.read(0, 16, null, true).catch(() => { });
+        // Force a queue submission boundary between the extract pass (which
+        // writes bufferA via atomicOr — bound as `storage, read_write` with
+        // `array<atomic<u32>>`) and the dilate-X pass (which reads bufferA
+        // bound as `storage, read` with `array<u32>`). Without this, the
+        // atomic writes are not reliably visible to the next pass — dilation
+        // produces empty output. Other inter-pass transitions in this
+        // pipeline (clear→extract, dilateX→Z→Y, Y→compact) rely on automatic
+        // intra-encoder synchronization without issue. Verified raw Dawn
+        // synchronizes this case correctly, so the bug is somewhere in
+        // PlayCanvas's compute dispatch / bind-group path.
+        this.device.submit();
         // X-pass: A → B
         this.dispatchX(slot, slot.bufferA, slot.bufferB, numXWords, outerNy, outerNz, halfExtentXZ);
         // Z-pass: B → A
@@ -9688,8 +9692,16 @@ const binIndices = (parent, lod) => {
  */
 const writeLod = async (options, fs) => {
     const { filename, iterations, createDevice, chunkCount, chunkExtent } = options;
-    const dataTable = convertToSpace(options.dataTable, Transform.IDENTITY, true);
-    const envDataTable = options.envDataTable ? convertToSpace(options.envDataTable, Transform.IDENTITY, true) : null;
+    // Operate in PLY space so per-leaf bounds in tree.bound are in the same
+    // coordinate frame as the SOG chunk data emitted by writeSog (which also
+    // converts to Transform.PLY). Without this, view-dependent streaming
+    // built on tree.bound picks the wrong chunks because the bounds are
+    // 180°-Z-rotated relative to the splat positions inside them.
+    // This intentionally mutates the input tables to avoid doubling peak
+    // memory during LOD export. Callers should treat writeLod as consuming its
+    // DataTable inputs.
+    const dataTable = convertToSpace(options.dataTable, Transform.PLY, true);
+    const envDataTable = options.envDataTable ? convertToSpace(options.envDataTable, Transform.PLY, true) : null;
     const outputDir = dirname(filename);
     // ensure top-level output folder exists
     await fs.mkdir(outputDir);
@@ -15201,8 +15213,14 @@ const voxelizeToBuffer = async (bvh, gpuVoxelization, gridBounds, voxelResolutio
     const buffer = new BlockMaskBuffer();
     const bStride = numBlocksX * numBlocksY;
     const batchSize = 16;
-    const MEGA_MAX_BATCHES = 512;
-    const MEGA_MAX_INDICES = 4 * 1024 * 1024;
+    // Caps for one mega-flush. Sized to keep a single compute dispatch's
+    // wall-clock comfortably under Windows D3D12 TDR (~2s watchdog) on slower
+    // GPUs without materially affecting throughput on fast GPUs (the
+    // double-buffered slots keep the GPU fed across the extra flushes).
+    // Output is bit-identical regardless: each batch's full Gaussian list rides
+    // with it, and slot buffers grow on demand to accommodate any oversize batch.
+    const MEGA_MAX_BATCHES = 256;
+    const MEGA_MAX_INDICES = 2 * 1024 * 1024;
     const maxBlocks = GpuVoxelization.MAX_BLOCKS_PER_BATCH;
     const numSlots = GpuVoxelization.NUM_SLOTS;
     const slotIndexArrays = [];
@@ -17008,21 +17026,32 @@ const cropToNavigable = (grid, gridBounds, voxelResolution) => {
         return { grid, gridBounds };
     }
     const { minBx, minBy, minBz, maxBx, maxBy, maxBz } = navBounds;
-    const cropMaxBx = maxBx + 1;
-    const cropMaxBy = maxBy + 1;
-    const cropMaxBz = maxBz + 1;
-    if (minBx === 0 && minBy === 0 && minBz === 0 &&
+    // Pad by 1 block on each side so the cropped grid retains the solid wall
+    // blocks immediately surrounding the navigable cavity. Matches the
+    // MARGIN = 1 pattern used by carve() before this re-crop strips it. The
+    // collision-mesh extractors treat out-of-grid as empty, so without this
+    // padding the mesh has holes wherever the cavity reaches the cropped
+    // boundary; with it, the mesh extractor sees a real SOLID→EMPTY
+    // transition at the cavity edge and emits a sealed wall there.
+    const MARGIN = 1;
+    const cropMinBx = Math.max(0, minBx - MARGIN);
+    const cropMinBy = Math.max(0, minBy - MARGIN);
+    const cropMinBz = Math.max(0, minBz - MARGIN);
+    const cropMaxBx = Math.min(nbx, maxBx + 1 + MARGIN);
+    const cropMaxBy = Math.min(nby, maxBy + 1 + MARGIN);
+    const cropMaxBz = Math.min(nbz, maxBz + 1 + MARGIN);
+    if (cropMinBx === 0 && cropMinBy === 0 && cropMinBz === 0 &&
         cropMaxBx === nbx && cropMaxBy === nby && cropMaxBz === nbz) {
         return { grid, gridBounds };
     }
     const cropBar = logger.bar('Cropping grid', grid.types.length);
-    const croppedGrid = grid.cropTo(minBx, minBy, minBz, cropMaxBx, cropMaxBy, cropMaxBz, done => cropBar.update(done));
+    const croppedGrid = grid.cropTo(cropMinBx, cropMinBy, cropMinBz, cropMaxBx, cropMaxBy, cropMaxBz, done => cropBar.update(done));
     cropBar.end();
     const blockSize = 4 * voxelResolution;
-    const croppedMin = new Vec3(gridBounds.min.x + minBx * blockSize, gridBounds.min.y + minBy * blockSize, gridBounds.min.z + minBz * blockSize);
+    const croppedMin = new Vec3(gridBounds.min.x + cropMinBx * blockSize, gridBounds.min.y + cropMinBy * blockSize, gridBounds.min.z + cropMinBz * blockSize);
     const croppedBounds = {
         min: croppedMin,
-        max: new Vec3(croppedMin.x + (cropMaxBx - minBx) * blockSize, croppedMin.y + (cropMaxBy - minBy) * blockSize, croppedMin.z + (cropMaxBz - minBz) * blockSize)
+        max: new Vec3(croppedMin.x + (cropMaxBx - cropMinBx) * blockSize, croppedMin.y + (cropMaxBy - cropMinBy) * blockSize, croppedMin.z + (cropMaxBz - cropMinBz) * blockSize)
     };
     return { grid: croppedGrid, gridBounds: croppedBounds };
 };
@@ -17149,13 +17178,27 @@ const writeVoxel = async (options, fs) => {
         gpuVoxelization = new GpuVoxelization(device);
         gpuVoxelization.uploadAllGaussians(pcDataTable, extentsResult.extents);
         // Align grid bounds to block boundaries BEFORE voxelization so the
-        // block coordinates used during voxelization match what the reader expects.
-        // When fillExterior runs, pad by halfExtent + 1 voxels per side so the
-        // boundary-face flood seeds survive the dilation (notably below the floor).
+        // block coordinates used during voxelization match what the reader
+        // expects. fillExterior and fillFloor both need a margin of empty
+        // voxels outside the splat's tight 3-sigma extents to do their job:
+        // fillExterior so the boundary-face flood seeds survive its dilation
+        // (notably below the floor), fillFloor so its column walk has empty
+        // XZ columns to convert into wall pillars and the dilation halo to
+        // extend the floor footprint outward.
+        //
+        // Lateral pad combines both as `dilation_radius + 1` voxels per side.
+        // Vertical pad is only contributed by exteriorPad — fillFloor's
+        // dilation is XZ-only, and Y padding would extend the wall pillars
+        // above the splat's natural ceiling and below its floor.
         const exteriorPad = hasFillExterior ?
             (Math.ceil(navExteriorRadius / voxelResolution) + 1) * voxelResolution :
             0;
-        let gridBounds = alignGridBounds(bounds.min.x - exteriorPad, bounds.min.y - exteriorPad, bounds.min.z - exteriorPad, bounds.max.x + exteriorPad, bounds.max.y + exteriorPad, bounds.max.z + exteriorPad, voxelResolution);
+        const floorPad = hasFloorFill ?
+            (Math.ceil(floorFillDilation / voxelResolution) + 1) * voxelResolution :
+            0;
+        const padXZ = Math.max(exteriorPad, floorPad);
+        const padY = exteriorPad;
+        let gridBounds = alignGridBounds(bounds.min.x - padXZ, bounds.min.y - padY, bounds.min.z - padXZ, bounds.max.x + padXZ, bounds.max.y + padY, bounds.max.z + padXZ, voxelResolution);
         const buffer = await voxelizeToBuffer(bvh, gpuVoxelization, gridBounds, voxelResolution, opacityCutoff);
         bvh = null;
         pcDataTable = null;