gaussian-splat-lite 1.5.0 → 1.5.2

package/CHANGELOG.md

@@ -7,28 +7,45 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.5.2] - 2026-10-29
+
+### Changed
+
+- `gsl-build-lod` reduces temporary-file reads for models larger than `--memory-budget`.
+
+### Fixed
+
+- Neural denoising no longer lets a still view turn grainy again when it keeps rendering for many seconds.
+- `gsl-build-lod` limits pending disk writes within `--memory-budget` to prevent excessive memory use on slow disks.
+
+## [1.5.1] - 2026-10-27
+
+### Changed
+
+- `gsl-build-lod` SH codebooks now match the original view-dependent color of large models more closely. Conversion takes slightly longer.
+
 ## [1.5.0] - 2026-10-27
 
 ### Added
 
-- Added `sources` to `RadStreamScheduler` and `SogStreamScheduler` to stream several inputs with one detail selection. The inputs share the splat budget and loading concurrency; RAD inputs also share both memory budgets, and each uses as much memory per Splat as the highest SH degree among them, limited by `maxSh`. See [RAD streaming](docs/RadStreamScheduler.md#multiple-inputs) and [SOG streaming](docs/SogStreamScheduler.md#multiple-inputs).
+- Added `sources` to `RadStreamScheduler` and `SogStreamScheduler` to stream several inputs with one detail selection. The inputs share the splat budget and loading concurrency; RAD inputs also share both memory budgets; inputs with different SH degrees all use the memory of the highest one, up to `maxSh`. See [RAD streaming](docs/RadStreamScheduler.md#multiple-inputs) and [SOG streaming](docs/SogStreamScheduler.md#multiple-inputs).
 - Added an `environment` option to `SogStreamScheduler` and each of its `sources`. Set it to `false` to skip that input's environment.
-- Added `maxSh` to `RadStreamScheduler` and `SogStreamScheduler` to limit SH decoding, storage, and rendering. Set it at creation to `0`–`3` (default `3`) to reduce SH memory use; `0` keeps only the base color. RAD page budgets account for the reduced storage, and the built-in SOG loader skips higher-order SH assets at `0`.
-- Added a loading-time `maxSh` option to `SplatMesh` and `Splats`, and a `SplatLoader.maxSh` setting (`0`–`4`, default `4`). PLY, SPZ, SOG, and RAD loads omit higher SH bands from CPU arrays and GPU source textures.
-- Added default SH codebook compression to `gsl-build-lod`: up to 65,536 shared SH entries and a 16-bit index per splat. Compression can reduce file size at the cost of view-dependent detail; small models may grow. Use `--cluster-sh=<n>` to change the default 10 refinement iterations or `--no-cluster-sh` to store coefficients directly. Clustering uses CPU workers within the memory target. See [SH codebook](docs/BuildRad.md#sh-codebook).
+- Added `maxSh` to `RadStreamScheduler` and `SogStreamScheduler` to limit SH decoding, storage, and rendering. Set it at creation to `0`–`3` (default `3`) to reduce memory use; `0` keeps only the base color, and streamed SOG then also skips downloading SH data.
+- Added a loading-time `maxSh` option to `SplatMesh` and `Splats`, and a `SplatLoader.maxSh` setting (`0`–`4`, default `4`). Lower values reduce memory use.
+- Added SH codebook compression to `gsl-build-lod`, on by default: splats share up to 65,536 SH entries. This can make large files much smaller at the cost of some view-dependent detail; small models may grow. Use `--cluster-sh=<n>` to change the default 10 refinement iterations or `--no-cluster-sh` to store SH without a codebook. Clustering stays within `--memory-budget`. See [SH codebook](docs/BuildRad.md#sh-codebook).
 
 ### Changed
 
 - Raised the minimum Node.js version to 22.12 for the package and `gsl-build-lod`.
 - `SplatMesh.maxSh` is now read-only and set through its constructor options, matching the streaming schedulers. Assigning `mesh.maxSh` now throws a `TypeError` in strict-mode code, including ES modules. Create a new mesh to change the limit. The viewer's Max SH control has been removed.
-- RAD streaming now uses fixed 65,536-splat page slots. Smaller chunks use a full slot; chunks larger than 65,536 splats are rejected during initialization.
+- RAD streaming no longer accepts files with chunks of more than 65,536 splats. Files from `gsl-build-lod` are unaffected.
 - RAD and SOG schedulers now create their own `THREE.Group`; the `group` constructor option has been removed. Add and transform `streaming.group` instead.
-- RAD and SOG streaming upload written texture layers before their batches are first displayed. Each scheduler limits pending source texture uploads to 24 MiB until rendering submits them, preventing skipped renders from accumulating larger uploads. A larger SOG region proceeds alone.
-- `gsl-build-lod` now quantizes SH in fixed `1/128` steps instead of using adaptive per-band ranges. Both codebook and direct output clip coefficients to `[-127/128, 127/128]`. With `--no-cluster-sh`, original SPZ splats retain their SH coefficients except `-1`, which clips to `-127/128`.
+- RAD and SOG streamed data now reaches the GPU only when you render. Keep rendering, not just calling `update()`, while waiting for `firstRenderable`.
+- With `--no-cluster-sh`, `gsl-build-lod` now keeps the view-dependent color of SPZ inputs almost exactly.
 
 ### Fixed
 
-- Fixed delayed cache memory reclamation in `gsl-build-lod` when reserving memory for worker threads.
+- Fixed `gsl-build-lod` briefly using more memory than `--memory-budget` when starting worker threads.
 
 ## [1.4.3] - 2026-10-25
 
@@ -703,7 +720,10 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 - Initial public release of the Three.js Gaussian Splatting renderer.
 
-[Unreleased]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.4.3...HEAD
+[Unreleased]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.5.2...HEAD
+[1.5.2]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.5.1...v1.5.2
+[1.5.1]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.5.0...v1.5.1
+[1.5.0]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.4.3...v1.5.0
 [1.4.3]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.4.2...v1.4.3
 [1.4.2]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.4.1...v1.4.2
 [1.4.1]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.4.0...v1.4.1

package/bin/build-lod.js

@@ -13,6 +13,7 @@ import { buildLod } from "./rad/lod.js";
 import { Pool } from "./rad/parallel.js";
 import { checkOutput, writeRad } from "./rad/rad.js";
 import { GIB, Workspace } from "./rad/storage.js";
+import { syncFiles } from "./rad/writeback.js";
 
 const help = `Convert PLY or SPZ files to RAD with levels of detail (LOD).
 
@@ -37,7 +38,7 @@ Options:
   -h, --help             Show this help
 
 SH4 inputs are accepted; coefficients above --max-sh are discarded.
-The memory target covers the whole conversion, worker threads included.
+The memory target covers the conversion, worker threads and pending disk writes included.
 Requires Node.js 22.12 or later. No compilation is required.`;
 
 function parse(args) {
@@ -139,7 +140,13 @@ async function convert(input, options, kernel, cancelled) {
       `${path.basename(input, path.extname(input))}-lod.rad`,
     );
   checkOutput(output, options.chunked);
-  const workspace = new Workspace(options.budget, options.tempDir, cancelled);
+  const workspace = new Workspace(
+    options.budget,
+    (files, state) =>
+      parentPort.postMessage({ method: "writeback", args: [files, state] }),
+    options.tempDir,
+    cancelled,
+  );
   const start = performance.now();
   console.log(
     `${input} -> ${output}\nMemory target: ${(options.budget / GIB).toFixed(3)} GiB`,
@@ -222,6 +229,7 @@ async function run(options, cancelled) {
 
 // Keep signal handling responsive while the conversion runs synchronous code.
 // The worker observes cancellation and unwinds its existing catch/finally blocks.
+// Cleanup finishes submitted writeback before closing files and exiting.
 async function start(options) {
   const cancelled = new Int32Array(new SharedArrayBuffer(4));
   let progressLine = "";
@@ -230,6 +238,7 @@ async function start(options) {
     progressLine = "";
   };
   const print = ({ method, args }) => {
+    if (method === "writeback") return syncFiles(...args, cancelled);
     if (method === "progress") {
       const [line, done] = args;
       if (process.stdout.isTTY) {
@@ -249,7 +258,9 @@ async function start(options) {
     const code = signal === "SIGINT" ? 130 : 143;
     if (Atomics.compareExchange(cancelled, 0, 0, code) === 0) {
       endProgress();
-      console.error(`${signal}: cancelling conversion and cleaning up...`);
+      console.error(
+        `${signal}: cancelling conversion; waiting for active disk I/O before cleanup...`,
+      );
     }
   };
   process.on("SIGINT", interrupt);

package/bin/decoder/decoder.js

@@ -78,10 +78,6 @@ function __wbg_get_imports() {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_new_from_slice_d85ad974cf8f6f35: function(arg0, arg1) {
-            const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
-            return ret;
-        },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = arg1.stack;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -95,6 +91,11 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(F32)) -> NamedExternref("Float32Array")`.
+            const ret = getArrayF32FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;

package/bin/rad/cluster.js

@@ -6,18 +6,21 @@ import { HALF } from "./math.js";
 import { WorkerGroup, clusterers } from "./parallel.js";
 import { Progress } from "./progress.js";
 import { SH_DIMS } from "./splats.js";
-import { PagedArray } from "./storage.js";
+import { PAGE_BYTES, PagedArray } from "./storage.js";
 
 // Codebook entries at most: RAD labels are 16-bit.
 const MAX_CODES = 65536;
 // Training reads SAMPLE_SHARE of the splats, and at least SAMPLES_PER_CODE
 // per entry; larger models train on a sample by weight, and only the final
-// assignment reads all. Entries start at evenly spaced training splats,
-// best at heavy ones: on Elevator (3.9M splats after LOD) 16 per entry fit
-// better than all splats, and on C-NorthSouth (111M) 5% fit 8.5% closer
-// than 16 per entry, for 5% more conversion time.
-const SAMPLES_PER_CODE = 16;
-const SAMPLE_SHARE = 0.05;
+// assignment reads all. Entries start at evenly spaced training splats.
+// With codebooks shrunk to keep 16 per entry at 5%, renders of Elevator and
+// JunkShop came 5–14% closer to the uncompressed SH at 10% than at 5%; on
+// C-NorthSouth (111M splats after LOD) clustering took about 185 s, not 170.
+// On Elevator (3.9M splats after LOD), 64 per entry, here all splats, came
+// 5.8% closer than 16 at full detail, with 41% fewer pixels off by more than
+// 32 levels in LOD views, in 18 s instead of 6 s.
+const SAMPLES_PER_CODE = 64;
+const SAMPLE_SHARE = 0.1;
 // Splats per job of a thread, and per call of the kernel.
 const JOB = 4096;
 const BATCH = 1024;
@@ -320,6 +323,13 @@ class Assigner extends WorkerGroup {
   }
 }
 
+// Rows that fit in the cache, allowing a partial page per column. Repeated
+// scans cache this prefix and bypass the rest to avoid evicting it.
+function fitting(bytes, row, columns) {
+  const pages = Math.floor(bytes / PAGE_BYTES) - columns;
+  return Math.max(0, Math.floor((pages * PAGE_BYTES) / row));
+}
+
 // Reads splats' SH as rows of half bits, the bands one after another, with
 // their weights, area × opacity as merging weighs them.
 class Rows {
@@ -327,16 +337,21 @@ class Rows {
     this.splats = splats;
     this.dims = dims;
     this.length = splats.length;
+    this.kept = Number.POSITIVE_INFINITY;
     this.column = new Uint16Array(JOB * SH_DIMS[SH_DIMS.length - 1]);
     this.records = new Float32Array(JOB * 16);
   }
 
+  keep(bytes) {
+    this.kept = fitting(bytes, this.dims * 2 + 64, this.splats.maxSh + 1);
+  }
+
   read(base, count, bits, weights) {
-    const { splats, dims, column } = this;
+    const { splats, dims, column, kept } = this;
     let offset = 0;
     for (let band = 0; band < splats.maxSh; band++) {
       const size = SH_DIMS[band];
-      splats.sh[band].read(base * size, column, count * size);
+      splats.sh[band].scan(base * size, column, count * size, kept * size);
       for (let i = 0; i < count; i++)
         for (let d = 0; d < size; d++)
           bits[i * dims + offset + d] = column[i * size + d];
@@ -346,10 +361,11 @@ class Rows {
   }
 
   weigh(base, count, weights) {
-    const records = this.splats.records.read(
+    const records = this.splats.records.scan(
       base * 16,
       this.records,
       count * 16,
+      this.kept * 16,
     );
     for (let i = 0; i < count; i++)
       weights[i] = records[i * 16 + 15] * records[i * 16 + 3];
@@ -361,13 +377,19 @@ class Sample {
   constructor(workspace, dims) {
     this.dims = dims;
     this.length = 0;
+    this.kept = Number.POSITIVE_INFINITY;
     this.bits = new PagedArray(workspace, Uint16Array);
     this.weights = new PagedArray(workspace, Float64Array);
   }
 
+  keep(bytes) {
+    this.kept = fitting(bytes, this.dims * 2 + 8, 2);
+  }
+
   read(base, count, bits, weights) {
-    this.bits.read(base * this.dims, bits, count * this.dims);
-    this.weights.read(base, weights, count);
+    const { dims, kept } = this;
+    this.bits.scan(base * dims, bits, count * dims, kept * dims);
+    this.weights.scan(base, weights, count, kept);
   }
 
   dispose() {
@@ -587,8 +609,8 @@ class Grouper {
 // weighted k-means as Spark does: entries start at evenly spaced splats,
 // each of `iterations` moves them to the weighted mean of their splats, an
 // entry without any stays, and a final pass labels each splat with its
-// nearest entry. Weights are area × opacity. Training uses 5% of the
-// splats, at least 16 per entry, sampled in proportion to their weights;
+// nearest entry. Weights are area × opacity. Training uses 10% of the
+// splats, at least 64 per entry, sampled in proportion to their weights;
 // with many entries, passes search only groups of them. Returns the
 // entries, `count` rows of `dims` SH coefficients, and the labels.
 export async function clusterSh(splats, iterations, module) {
@@ -650,11 +672,21 @@ export async function clusterSh(splats, iterations, module) {
       extra,
       Math.ceil(training.length / size),
     );
+    // Measure worker growth between passes: bypass reads do not allocate
+    // pages or trigger measurements. Leave room for labels when the final
+    // pass shares the training cache.
+    const labelPages = sampled ? 0 : Math.ceil((length * 2) / PAGE_BYTES);
+    const keep = () => {
+      workspace.adjust();
+      training.keep(workspace.capacity - labelPages * PAGE_BYTES);
+    };
+    keep();
     const codes = new Float64Array(count * dims);
     const sums = new Float64Array(count * dims);
     const totals = new Float64Array(count);
     const bits = new Uint16Array(dims);
     const weight = new Float64Array(1);
+    // Read seeds past the cached prefix directly, preserving training rows.
     for (let c = 0; c < count; c++) {
       // Spark computes the seed rows in single precision.
       const row = Math.floor(
@@ -702,6 +734,7 @@ export async function clusterSh(splats, iterations, module) {
         layout(codes, order, dims, center, blocked, norms);
         await assigner.use("codes", { codes: blocked, norms, center });
       }
+      keep();
       if (!last) {
         sums.fill(0);
         totals.fill(0);

package/bin/rad/heap.js

@@ -247,7 +247,7 @@ export function sortSplats(splats, pool) {
   // rank alone keeps splats of equal size in index order.
   const items = new IndexArray(workspace);
   for (let i = 0; i < count; i++) {
-    const key = rank(-splats.feature(i));
+    const key = rank(-splats.sizes.get(i));
     const words = items.page(i * 2, true);
     const offset = (i * 2) & items.mask;
     words[offset] = key;
@@ -266,5 +266,4 @@ export function sortSplats(splats, pool) {
   sorted.dispose();
   ordering.finish();
   splats.reorder(order, pool);
-  order.dispose();
 }

package/bin/rad/lod.js

@@ -49,21 +49,17 @@ export function buildLod(splats, lodBase, pool) {
   splats.weight.dispose();
   selection.finish(`${retainedCount} nodes retained`);
 
-  // Ordering reads sizes at random; a copy without the rest of each record
-  // stays cached.
-  const sizes = new PagedArray(workspace, Float32Array);
-  const sizing = new Progress("Reading LOD sizes", splats.length);
-  for (let index = 0; index < splats.length; index++) {
-    sizes.set(index, splats.feature(index));
-    if ((index & 4095) === 0) sizing.update(index);
-  }
-  sizing.finish();
+  // Ordering reads sizes at random, from a column without the rest of each
+  // record, and lists them in logical order for chunkTree().
+  const sizes = splats.sizes;
   // A splat's logical index is its position in `order`. Its children get
   // consecutive logical indices: `first` and the `counts` - 1 after it.
   const order = new IndexArray(workspace);
   const first = new IndexArray(workspace);
   const counts = new IndexArray(workspace);
+  const ordered = new PagedArray(workspace, Float32Array);
   order.push(root);
+  ordered.push(sizes.get(root));
   // The splats to visit, by logical index, splat and size: the frontier of a
   // pass as triples of words, and a stack within it.
   let frontier = new IndexArray(workspace);
@@ -120,17 +116,22 @@ export function buildLod(splats, lodBase, pool) {
         const start = order.length;
         first.set(logical, start);
         counts.set(logical, count);
-        for (let c = 0; c < count; c++) order.push(list[c]);
         if (top + count > logicals.length) {
           logicals = grow(logicals, top, top + count);
           indices = grow(indices, top, top + count);
           lengths = grow(lengths, top, top + count);
         }
-        for (let c = count - 1; c >= 0; c--) {
-          logicals[top] = start + c;
-          indices[top] = list[c];
-          lengths[top++] = sizes.get(list[c]);
+        // Each child's size is read once, at random, for both uses.
+        for (let c = 0; c < count; c++) {
+          const length = sizes.get(list[c]);
+          order.push(list[c]);
+          ordered.push(length);
+          const at = top + count - 1 - c;
+          logicals[at] = start + c;
+          indices[at] = list[c];
+          lengths[at] = length;
         }
+        top += count;
       }
     }
     frontier.dispose();
@@ -143,7 +144,7 @@ export function buildLod(splats, lodBase, pool) {
   sizes.dispose();
   kept.dispose();
   ordering.finish();
-  chunkTree(splats, order, first, counts, pool);
+  chunkTree(splats, order, first, counts, ordered, pool);
   order.dispose();
 }
 
@@ -152,24 +153,8 @@ export function buildLod(splats, lodBase, pool) {
 function mergeLevels(splats, pool) {
   const initial = splats.length;
   const workspace = splats.workspace;
-  // Merged splats lie within the leaves' bounds. merge() reads the leaves'
-  // weights.
-  const bounds = {
-    min: [0, 1, 2].map(() => Number.POSITIVE_INFINITY),
-    max: [0, 1, 2].map(() => Number.NEGATIVE_INFINITY),
-  };
-  const record = new Float64Array(16);
-  const preparing = new Progress("Preparing LOD bounds", initial);
-  for (let i = 0; i < initial; i++) {
-    splats.read(i, record);
-    for (let d = 0; d < 3; d++) {
-      bounds.min[d] = Math.min(bounds.min[d], record[d]);
-      bounds.max[d] = Math.max(bounds.max[d], record[d]);
-    }
-    splats.weight.set(i, record[15] * record[3]);
-    if ((i & 4095) === 0) preparing.update(i);
-  }
-  preparing.finish();
+  // Merged splats lie within the leaves' bounds.
+  const { bounds, sizes } = splats;
   const removed = new PagedArray(workspace, Uint8Array);
   const similarities = new Similarities(splats);
   let active = new Heap(workspace);
@@ -187,7 +172,7 @@ function mergeLevels(splats, pool) {
   const added = new Cells(18);
   const near = new Cells(20);
   for (
-    let level = Math.ceil(Math.log2(Math.max(splats.feature(0), 0.000001)));
+    let level = Math.ceil(Math.log2(Math.max(sizes.get(0), 0.000001)));
     ;
     level++
   ) {
@@ -199,14 +184,14 @@ function mergeLevels(splats, pool) {
     let high = initial;
     while (low < high) {
       const middle = Math.floor((low + high) / 2);
-      if (splats.feature(middle) <= step) low = middle + 1;
+      if (sizes.get(middle) <= step) low = middle + 1;
       else high = middle;
     }
     const { grid, queue } = Progress.inline(() => {
       const adding = new Progress(`Preparing level ${level}`, low - frontier);
       const previous = frontier;
       while (frontier < low) {
-        active.push(frontier, -splats.feature(frontier));
+        active.push(frontier, -sizes.get(frontier));
         frontier++;
         if ((frontier & 4095) === 0) adding.update(frontier - previous);
       }
@@ -323,7 +308,7 @@ function mergeLevels(splats, pool) {
         removed.set(other, 1);
         grid.remove(self);
         grid.remove(best);
-        const feature = splats.feature(merged);
+        const feature = sizes.get(merged);
         if (feature > step) next.push(merged, -feature);
         else {
           const terms =
@@ -404,8 +389,8 @@ function sort(values, count) {
 
 // Lays out the tree in chunks of 65536 splats and moves every column into
 // that order. Children become consecutive rows: childStart is then the row of
-// a splat's first child.
-function chunkTree(splats, order, first, counts, pool) {
+// a splat's first child. `sizes` are the splats' sizes in logical order.
+function chunkTree(splats, order, first, counts, sizes, pool) {
   const workspace = splats.workspace;
   const nodes = splats.length;
   for (const column of [splats.childStart, splats.childCount, splats.children])
@@ -426,13 +411,6 @@ function chunkTree(splats, order, first, counts, pool) {
     "Reordering LOD nodes",
   );
   logical.dispose();
-  const sizes = new PagedArray(workspace, Float32Array);
-  const sizing = new Progress("Reading chunk sizes", order.length);
-  for (let index = 0; index < order.length; index++) {
-    sizes.set(index, splats.feature(index));
-    if ((index & 4095) === 0) sizing.update(index);
-  }
-  sizing.finish();
   // The row of each splat's first child.
   const starts = new PagedArray(workspace, Float64Array);
   const indices = new IndexArray(workspace);
@@ -629,28 +607,31 @@ function chunkTree(splats, order, first, counts, pool) {
     "Reordering child offsets",
   );
   chunked.dispose();
-  // The SH coefficients are still in node order.
-  const shOrder = new Progress("Collecting LOD SH order", indices.length);
-  for (let i = 0; i < indices.length; i++) {
-    indices.set(i, order.get(indices.get(i)));
-    if ((i & 4095) === 0) shOrder.update(i);
-  }
-  shOrder.finish();
-  const nodeOrder = new Permutation(
-    workspace,
-    indices,
-    nodes,
-    "Preparing LOD SH order",
-  );
-  for (let band = 0; band < splats.maxSh; band++)
-    splats.sh[band] = nodeOrder.apply(
-      splats.sh[band],
-      SH_DIMS[band],
-      pool,
-      false,
-      `Reordering LOD SH${band + 1}`,
+  // The SH coefficients are still in the order of mergeSh().
+  if (splats.maxSh) {
+    const shOrder = new Progress("Collecting LOD SH order", indices.length);
+    for (let i = 0; i < indices.length; i++) {
+      indices.set(i, splats.shRow(order.get(indices.get(i))));
+      if ((i & 4095) === 0) shOrder.update(i);
+    }
+    shOrder.finish();
+    splats.shOrder.dispose();
+    const nodeOrder = new Permutation(
+      workspace,
+      indices,
+      nodes,
+      "Preparing LOD SH order",
     );
-  nodeOrder.dispose();
+    for (let band = 0; band < splats.maxSh; band++)
+      splats.sh[band] = nodeOrder.apply(
+        splats.sh[band],
+        SH_DIMS[band],
+        pool,
+        false,
+        `Reordering LOD SH${band + 1}`,
+      );
+    nodeOrder.dispose();
+  }
   first.dispose();
   splats.length = indices.length;
   indices.dispose();