gaussian-splat-lite 1.4.1 → 1.4.2

package/dist/gaussian-splat-lite.module.js

@@ -3895,19 +3895,22 @@ function hasViewDependentColor(mapping) {
 }
 const SPLATS_PER_INSTANCE = 128;
 class SplatGeometry extends THREE.InstancedBufferGeometry {
-  constructor() {
+  constructor(triangle = false) {
     super();
-    const vertices = new Float32Array(SPLATS_PER_INSTANCE * 12);
-    const indices = new Uint16Array(SPLATS_PER_INSTANCE * 6);
+    const corners = triangle ? TRIANGLE_CORNERS : QUAD_CORNERS;
+    const order = triangle ? TRIANGLE_INDICES : QUAD_INDICES;
+    const vertexCount = corners.length / 2;
+    const vertices = new Float32Array(SPLATS_PER_INSTANCE * vertexCount * 3);
+    const indices = new Uint16Array(SPLATS_PER_INSTANCE * order.length);
     for (let splat = 0; splat < SPLATS_PER_INSTANCE; splat++) {
-      for (let vertex = 0; vertex < 4; vertex++) {
-        const offset = splat * 12 + vertex * 3;
-        vertices[offset] = QUAD_VERTICES[vertex * 3];
-        vertices[offset + 1] = QUAD_VERTICES[vertex * 3 + 1];
+      for (let vertex = 0; vertex < vertexCount; vertex++) {
+        const offset = (splat * vertexCount + vertex) * 3;
+        vertices[offset] = corners[vertex * 2];
+        vertices[offset + 1] = corners[vertex * 2 + 1];
         vertices[offset + 2] = splat;
       }
-      for (let index2 = 0; index2 < 6; index2++)
-        indices[splat * 6 + index2] = splat * 4 + QUAD_INDICES[index2];
+      for (let index2 = 0; index2 < order.length; index2++)
+        indices[splat * order.length + index2] = splat * vertexCount + order[index2];
     }
     this.setAttribute("position", new THREE.BufferAttribute(vertices, 3));
     this.setIndex(new THREE.BufferAttribute(indices, 1));
@@ -3916,21 +3919,17 @@ class SplatGeometry extends THREE.InstancedBufferGeometry {
     this.instanceCount = Math.ceil(count / SPLATS_PER_INSTANCE);
   }
 }
-const QUAD_VERTICES = new Float32Array([
+const QUAD_CORNERS = new Float32Array([-1, -1, 1, -1, 1, 1, -1, 1]);
+const TRIANGLE_CORNERS = new Float32Array([
+  -Math.sqrt(3),
   -1,
+  Math.sqrt(3),
   -1,
   0,
-  1,
-  -1,
-  0,
-  1,
-  1,
-  0,
-  -1,
-  1,
-  0
+  2
 ]);
 const QUAD_INDICES = new Uint16Array([0, 2, 1, 0, 3, 2]);
+const TRIANGLE_INDICES = new Uint16Array([0, 2, 1]);
 const variants = /* @__PURE__ */ new WeakMap();
 function registerStochasticSplatMaterial(material, createVariant) {
   variants.set(material, createVariant);
@@ -5601,10 +5600,7 @@ class ProjectedSplats {
   constructor(renderer, uniforms) {
     this.renderer = renderer;
     this.uniforms = uniforms;
-    this.indirect = new IndirectStorageBufferAttribute(
-      new Uint32Array([SPLATS_PER_INSTANCE * 6, 0, 0, 0, 0]),
-      1
-    );
+    this.indirect = new IndirectStorageBufferAttribute(new Uint32Array(5), 1);
     this.error = null;
     this.cache = new ProjectionCache();
     this.visibleCount = new StorageBufferAttribute(new Uint32Array(1), 1);
@@ -5644,7 +5640,9 @@ class ProjectedSplats {
       // RADIX_SORT_MODE_IDS value of the current key encoding.
       sortMode: { value: 0 },
       // NDC translation the draw applies to unjittered projections.
-      projectionJitter: { value: new THREE.Vector2() }
+      projectionJitter: { value: new THREE.Vector2() },
+      // Indices per instance of the drawn geometry, quads or triangles.
+      indexCount: { value: 0 }
     };
     const count = N.storage(this.visibleCount, "uint").setName("gslVisibleCount").toReadOnly().element(0);
     this.sorter = new WebGPURadixSort(1, this.keys, {
@@ -5656,13 +5654,16 @@ class ProjectedSplats {
         this.limits.maxBufferSize
       )
     });
-    const drawCount = N.storage(this.indirect, "uint").setName("gslDrawIndirect").element(1);
+    const drawArgs = N.storage(this.indirect, "uint").setName(
+      "gslDrawIndirect"
+    );
     const counter = N.storage(this.visibleCount, "uint").setName("gslVisibleCount").toAtomic();
     this.resetCount = N.Fn(() => {
       N.atomicStore(counter.element(0), N.uint(0));
     })().compute(1, [1]).setName("Splat reset visible count");
     this.finish = N.Fn(() => {
-      drawCount.assign(
+      drawArgs.element(0).assign(uniformBinding(this.state, "indexCount", "uint"));
+      drawArgs.element(1).assign(
         count.add(SPLATS_PER_INSTANCE - 1).div(N.uint(SPLATS_PER_INSTANCE))
       );
     })().compute(1, [1]).setName("Splat visible draw arguments");
@@ -5914,6 +5915,7 @@ class ProjectedSplats {
     const monoProjection = !multiView && unjittered && getProjectionJitter(camera.projectionMatrix, unjittered, jitter) ? unjittered : null;
     geometry.setIndirect(this.indirect);
     geometry.setSplatCount(Math.max(1, accumulator.numSplats));
+    this.state.indexCount.value = geometry.index.count;
     const inputs = this.pendingInputs;
     let length = 0;
     inputs[length++] = accumulator;
@@ -5922,6 +5924,7 @@ class ProjectedSplats {
     inputs[length++] = accumulator.viewOrigin.y;
     inputs[length++] = accumulator.viewOrigin.z;
     inputs[length++] = cameras.length;
+    inputs[length++] = geometry.index.count;
     inputs[length++] = stochastic;
     inputs[length++] = !stochastic && radial;
     inputs[length++] = sortMode;
@@ -6108,9 +6111,11 @@ class GaussianSplatRenderer extends THREE.Mesh {
       depthTest: options.depthTest ?? true,
       depthWrite: options.depthWrite ?? false
     });
-    const geometry = new SplatGeometry();
+    const geometries = [new SplatGeometry(), new SplatGeometry(true)];
+    const geometry = geometries[Number(stochastic)];
     const material = backend.selectMaterial(stochastic);
     super(geometry, material);
+    this.geometries = geometries;
     this.materialState = new MaterialState(material);
     this.frameCallbacks = true;
     this.renderSize = new THREE.Vector2();
@@ -6214,7 +6219,7 @@ class GaussianSplatRenderer extends THREE.Mesh {
       accumulator.dispose();
     }
     this.accumulators.length = 0;
-    this.geometry.dispose();
+    for (const geometry of this.geometries) geometry.dispose();
   }
   /** Native WebGPU sorts on the GPU before drawing; WebGL sorts in a worker. */
   get synchronousSort() {
@@ -6266,13 +6271,11 @@ class GaussianSplatRenderer extends THREE.Mesh {
     const active = this.backend.kind === "webgpu" || this.display.numSplats === 0 ? this._stochastic : this.display.hasStochasticSeeds;
     if (active === this.stochasticFrame) return;
     this.stochasticFrame = active;
-    this.selectMaterial();
-    this.setDirty();
-  }
-  selectMaterial() {
-    const material = this.backend.selectMaterial(this.stochasticFrame);
-    this.applyMaterialState(this.stochasticFrame, material);
+    this.geometry = this.geometries[Number(active)];
+    const material = this.backend.selectMaterial(active);
+    this.applyMaterialState(active, material);
     this.material = material;
+    this.setDirty();
   }
   applyMaterialState(stochasticActive, material = this.material) {
     this.materialState.sync(material, this.material);
@@ -7196,74 +7199,6 @@ ${CATMULL_ROM_WEIGHTS}
 fn catmullRom(image: texture_2d<f32>, uv: vec2f) -> vec4f {
   return catmullRomSpan(image, uv).value;
 }
-
-// Lanczos-3 without its corner taps, from nine bilinear taps: the middle pair
-// of each axis is one tap and the other four pixels of an axis one each. A
-// history that is resampled once per frame loses fine detail with every pass,
-// and this kernel loses about half of what Catmull-Rom does. Its negative
-// lobes would ring over such a history, so the result is kept inside what the
-// four pixels around the position span. At a pixel's centre it returns the
-// pixel.
-struct LanczosWeights {
-  low: vec3f,
-  high: vec3f,
-};
-fn lanczosWeights(t: f32) -> LanczosWeights {
-  // Integer-shifted sinc taps share their sine. Angle addition supplies the
-  // other factor, reducing twelve sine evaluations per axis to three trig calls.
-  let x: f32 = 3.14159265 * t;
-  let s: f32 = sin(x / 3.0);
-  let c: f32 = 0.866025404 * cos(x / 3.0);
-  let scale: f32 = 0.303963551 * sin(x);
-  let terms: vec3f = scale * vec3f(c - 0.5 * s, -c - 0.5 * s, s);
-  let low: vec3f = vec3f(t + 2.0, t + 1.0, t);
-  let high: vec3f = vec3f(t - 1.0, t - 2.0, t - 3.0);
-  var w: LanczosWeights;
-  w.low = terms / max(low * low, vec3f(1e-20));
-  w.high = terms / max(high * high, vec3f(1e-20));
-  if (abs(x) < 1e-5) { w.low.z = 1.0; }
-  if (abs(3.14159265 * (t - 1.0)) < 1e-5) { w.high.x = 1.0; }
-  return w;
-}
-struct LanczosKernel {
-  base: vec2f,
-  centre: vec2f,
-  middle: f32,
-  wx: vec4f,
-  wy: vec4f,
-  total: f32,
-}
-fn lanczosKernel(uv: vec2f) -> LanczosKernel {
-  let position: vec2f = uv * P.size - 0.5;
-  var k: LanczosKernel;
-  k.base = floor(position);
-  let t: vec2f = position - k.base;
-  let x: LanczosWeights = lanczosWeights(t.x);
-  let y: LanczosWeights = lanczosWeights(t.y);
-  let middle: vec2f = vec2f(x.low.z + x.high.x, y.low.z + y.high.x);
-  k.centre = (k.base + vec2f(x.high.x, y.high.x) / middle + 0.5) * P.invSize;
-  k.middle = middle.x * middle.y;
-  k.wx = vec4f(x.low.xy, x.high.yz) * middle.y;
-  k.wy = vec4f(y.low.xy, y.high.yz) * middle.x;
-  k.total = k.middle;
-  for (var i: i32 = 0; i < 4; i++) { k.total += k.wx[i] + k.wy[i]; }
-  return k;
-}
-fn lanczosCross(image: texture_2d<f32>, k: LanczosKernel) -> vec4f {
-  var sum: vec4f = textureSampleLevel(image, linearSampler, k.centre, 0.0) * k.middle;
-  const offsets = array<f32, 4>(-1.5, -0.5, 2.5, 3.5);
-  for (var i: i32 = 0; i < 4; i++) {
-    let along: vec2f = (k.base + offsets[i]) * P.invSize;
-    sum += textureSampleLevel(image, linearSampler, vec2f(along.x, k.centre.y), 0.0) * k.wx[i];
-    sum += textureSampleLevel(image, linearSampler, vec2f(k.centre.x, along.y), 0.0) * k.wy[i];
-  }
-  let p: vec2i = vec2i(k.base);
-  let a: vec4f = textureLoad(image, bounded(p), 0);
-  let b: vec4f = textureLoad(image, bounded(p + vec2i(1, 0)), 0);
-  let c: vec4f = textureLoad(image, bounded(p + vec2i(0, 1)), 0);
-  let d: vec4f = textureLoad(image, bounded(p + vec2i(1, 1)), 0);
-  return clamp(sum / k.total, min(min(a, b), min(c, d)), max(max(a, b), max(c, d)));
-}
 `
 );
 const TAPS = (
@@ -7617,7 +7552,7 @@ fn mean3x3(image: texture_2d<f32>, position: vec2f, offset: vec2f) -> vec4f {
 const QUALITY_RESAMPLING = (
   /* wgsl */
   `
-// Full Catmull-Rom for the denoised history, retaining all four corner taps.
+// Full Catmull-Rom for Quality histories, retaining all four corner taps.
 fn catmullRomNine(image: texture_2d<f32>, uv: vec2f) -> vec4f {
   let position: vec2f = uv * P.size;
 ${CATMULL_ROM_WEIGHTS}
@@ -7935,7 +7870,7 @@ ${groups.map(
 // half-resolution result.
 @group(0) @binding(11) var wideTexture: texture_2d<f32>;
 @group(0) @binding(12) var depthPrevious: texture_2d<f32>;
-${MEAN_3X3}${weights.compact ? "" : QUALITY_RESAMPLING}${BLOCKS}
+${weights.compact ? MEAN_3X3 : QUALITY_RESAMPLING}${BLOCKS}
 // The frame's existing 4x4 mean, used only for rejected surfaces.
 @group(0) @binding(13) var rejectedTexture: texture_2d<f32>;
 ${COARSE}
@@ -7983,13 +7918,10 @@ ${weights.compact ? "" : "  let d: vec4f = textureLoad(filteredTexture, p, 0);"}
   var same: f32 = 1.0;
   let sparse: f32 = blockSparse(p);
   var sparseMotion: f32 = 0.0;
-${weights.movingMean ? `  // Where the history was, for the accumulated path's mean below.
-  var historyUv: vec2f = position.xy * P.invSize;` : ""}
   if (P.historyValid > 0.5) {
     let z: f32 = blockDepth(p);
     let h: History = reproject(position.xy, z);
     valid = h.valid;
-${weights.movingMean ? "    historyUv = h.uv;" : ""}
     // The pixel's own motion, or what a turn of the camera sweeps over half
     // the view, whichever is more: at the centre of a turn the first is
     // small while every surface there shows a new face. An orthographic
@@ -8020,9 +7952,9 @@ ${weights.movingMean ? "    historyUv = h.uv;" : ""}
 ${weights.compact ? `      // The accumulated history keeps many frames while the camera moves
       // slowly: read bilinearly, it lost detail with every one of them.
       sr = max(catmullRom(previousAccumulated, h.uv), vec4f(0.0));
-      dr = max(textureSampleLevel(previousDenoised, linearSampler, h.uv, 0.0), vec4f(0.0));` : `      sr = max(lanczosCross(previousAccumulated, lanczosKernel(h.uv)), vec4f(0.0));
-      // The two short histories take Catmull-Rom: what it blurs over a few
-      // frames is noise more than detail there.
+      dr = max(textureSampleLevel(previousDenoised, linearSampler, h.uv, 0.0), vec4f(0.0));` : `      // Full Catmull-Rom avoids the Lanczos cross kernel's frequency gain
+      // when periodic surface detail is reprojected over many frames.
+      sr = max(catmullRomNine(previousAccumulated, h.uv), vec4f(0.0));
       dr = max(catmullRomNine(previousDenoised, h.uv), vec4f(0.0));`}
       a = previousStatistics(h.uv);
     }
@@ -8099,24 +8031,7 @@ ${weights.compact ? `  let source: vec4f = shifted;
   let error: f32 = sqrt(max(y2 - ys * ys, 0.0) / (ns + 1e-3) + 1e-10);
   let ramp: f32 = 1.0 - exp(-ns / ${float(weights.gateFrames)});
   let keep: f32 = ramp * (1.0 - clamp(${float(weights.gamma)} * error, 0.0, 1.0)) * trust.w;
-${weights.movingMean ? `  // While the camera moves, the accumulated path holds few samples of the
-  // new view and its grain shows: it is shown from the 3x3 mean of its
-  // history and this frame's filtered sample. What it keeps stays sharp, so
-  // a camera that stops settles as before. This display-only smoothing does
-  // not track moving objects: with a still camera they continue to use the
-  // existing history rejection.
-  var shownAccumulated: vec4f = s;
-  if (P.historyValid > 0.5 && P.cameraStill < 0.5) {
-    let held: vec4f = max(mean3x3(previousAccumulated, historyUv * P.size, vec2f(0.0)), vec4f(0.0));
-    let moving: f32 = speed * speed / (speed * speed + ${float(weights.movingKnee * weights.movingKnee)});
-    let smoothed: vec4f = (held * ws + filtered) / ds;
-    // Only where the two differ by what the mean's noise explains: a larger
-    // difference is detail, and stays.
-    let differ: f32 = luma(abs(smoothed.rgb - s.rgb));
-    let spread: f32 = ${float(weights.movingNoise)} * error * error;
-    shownAccumulated = mix(s, smoothed, ${float(weights.movingMean)} * moving * spread / (spread + differ * differ + 1e-10));
-  }
-  let composite: vec4f = mix(dn, shownAccumulated, keep);` : "  let composite: vec4f = mix(dn, s, keep);"}
+  let composite: vec4f = mix(dn, s, keep);
   // Stabilization: a predicted blend with the previous image, which may stay
   // as far from this frame's result as half of what it spans around the
   // pixel, plus a slack. Taking that span from this frame's result instead
@@ -10954,7 +10869,7 @@ const quality = {
   }
 };
 const neuralDenoiseModels = {
-  quality: { ...quality, movingMean: 1, movingNoise: 16 },
+  quality,
   performance: { ...quality, compact: true, compactMix: [0.5, 0.75] }
 };
 class StochasticCoverage {