gaussian-splat-lite 1.4.0 → 1.4.2

package/dist/gaussian-splat-lite.cjs

@@ -3914,19 +3914,22 @@ function hasViewDependentColor(mapping) {
 }
 const SPLATS_PER_INSTANCE = 128;
 class SplatGeometry extends THREE__namespace.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__namespace.BufferAttribute(vertices, 3));
     this.setIndex(new THREE__namespace.BufferAttribute(indices, 1));
@@ -3935,21 +3938,17 @@ class SplatGeometry extends THREE__namespace.InstancedBufferGeometry {
     this.instanceCount = Math.ceil(count / SPLATS_PER_INSTANCE);
   }
 }
-const QUAD_VERTICES = new Float32Array([
-  -1,
+const QUAD_CORNERS = new Float32Array([-1, -1, 1, -1, 1, 1, -1, 1]);
+const TRIANGLE_CORNERS = new Float32Array([
+  -Math.sqrt(3),
   -1,
-  0,
-  1,
+  Math.sqrt(3),
   -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);
@@ -4757,37 +4756,16 @@ class WebGLSplatBackend {
     this.stochasticMaterial.dispose();
   }
 }
-function createTAAState(makeUniform, targets, nodeLogDepth = false, margin = 0) {
-  const uniforms = {
-    renderSize: makeUniform(new THREE.Vector2(1, 1)),
-    projection: makeUniform(new THREE.Matrix4()),
-    unjitteredProjection: makeUniform(new THREE.Matrix4()),
-    previousProjection: makeUniform(new THREE.Matrix4()),
-    viewToPreviousClip: makeUniform(new THREE.Matrix4()),
-    previousViewToView: makeUniform(new THREE.Matrix4()),
-    valid: makeUniform(false),
-    reversed: makeUniform(false),
-    logarithmic: makeUniform(false),
-    // Log-depth parameters: x is the current frame, y is the previous frame.
-    logFar: makeUniform(new THREE.Vector2()),
-    logNear: makeUniform(new THREE.Vector2()),
-    // Parameters are copied from the owner before each resolve.
-    depthThreshold: makeUniform(0),
-    edgeDepthDiff: makeUniform(0),
-    maxMotionLength: makeUniform(0),
-    useSubpixelCorrection: makeUniform(false),
-    luminanceCoefficients: makeUniform(new THREE.Vector3())
-  };
+function createNeuralDenoiseState(targets, margin) {
   const baseProjection = new THREE.Matrix4();
-  const previousViewProjection = new THREE.Matrix4();
-  const previousWorld = new THREE.Matrix4();
-  const viewMatrix = new THREE.Matrix4();
   return {
-    uniforms,
+    size: new THREE.Vector2(1, 1),
+    projection: new THREE.Matrix4(),
+    valid: false,
     historyIndex: 0,
     jitterIndex: 0,
     reset() {
-      uniforms.valid.value = false;
+      this.valid = false;
       this.jitterIndex = 0;
     },
     setSize(width, height) {
@@ -4797,10 +4775,9 @@ function createTAAState(makeUniform, targets, nodeLogDepth = false, margin = 0)
       if (source.width === w + margin && source.height === h + margin) return;
       source.setSize(w + margin, h + margin);
       for (const target of others) target.setSize(w, h);
-      uniforms.renderSize.value.set(w, h);
+      this.size.set(w, h);
       this.reset();
     },
-    // Only the capture target takes stencil; history stores plain depth.
     setStencil(stencil) {
       const source = targets[0];
       const depthTexture = source.depthTexture;
@@ -4814,50 +4791,18 @@ function createTAAState(makeUniform, targets, nodeLogDepth = false, margin = 0)
         camera,
         baseProjection,
         this.jitterIndex,
-        uniforms.renderSize.value.x,
-        uniforms.renderSize.value.y
+        this.size.x,
+        this.size.y
       );
     },
     endCapture(camera) {
-      uniforms.projection.value.copy(camera.projectionMatrix);
+      this.projection.copy(camera.projectionMatrix);
       restoreProjection(camera, baseProjection);
     },
-    prepareResolve(camera, parameters2) {
-      const near = Math.max(camera.near, 1e-6);
-      uniforms.logFar.value.x = Math.log2(
-        nodeLogDepth ? camera.far / near : camera.far + 1
-      );
-      uniforms.logNear.value.x = near;
-      uniforms.unjitteredProjection.value.copy(camera.projectionMatrix);
-      uniforms.viewToPreviousClip.value.multiplyMatrices(
-        previousViewProjection,
-        camera.matrixWorld
-      );
-      uniforms.previousViewToView.value.multiplyMatrices(
-        viewMatrix.copy(camera.matrixWorld).invert(),
-        previousWorld
-      );
-      uniforms.depthThreshold.value = parameters2.depthThreshold;
-      uniforms.edgeDepthDiff.value = parameters2.edgeDepthDiff;
-      uniforms.maxMotionLength.value = parameters2.maxMotionLength;
-      uniforms.useSubpixelCorrection.value = parameters2.useSubpixelCorrection;
-      THREE.ColorManagement.getLuminanceCoefficients(
-        uniforms.luminanceCoefficients.value
-      );
-      return uniforms.reversed.value ? THREE.NeverDepth : THREE.AlwaysDepth;
-    },
-    advance(camera) {
-      previousViewProjection.multiplyMatrices(
-        camera.projectionMatrix,
-        viewMatrix
-      );
-      previousWorld.copy(camera.matrixWorld);
-      uniforms.previousProjection.value.copy(uniforms.projection.value);
-      uniforms.logFar.value.y = uniforms.logFar.value.x;
-      uniforms.logNear.value.y = uniforms.logNear.value.x;
+    advance() {
       this.historyIndex = 1 - this.historyIndex;
-      uniforms.valid.value = true;
-      this.jitterIndex = (this.jitterIndex + 1) % taaJitterOffsets.length;
+      this.valid = true;
+      this.jitterIndex = (this.jitterIndex + 1) % jitterOffsets.length;
     }
   };
 }
@@ -4872,16 +4817,16 @@ function halton(index2, base) {
   }
   return result;
 }
-const taaJitterOffsets = Array.from({ length: 32 }, (_, i) => [
+const jitterOffsets = Array.from({ length: 32 }, (_, i) => [
   halton(i + 1, 2) - 0.5,
   halton(i + 1, 3) - 0.5
 ]);
 const projections = /* @__PURE__ */ new WeakMap();
-const getTAAProjection = (camera) => projections.get(camera);
+const getUnjitteredProjection = (camera) => projections.get(camera);
 function jitterProjection(camera, base, index2, width, height) {
   base.copy(camera.projectionMatrix);
   projections.set(camera, base);
-  const [x, y] = taaJitterOffsets[index2];
+  const [x, y] = jitterOffsets[index2];
   const elements = camera.projectionMatrix.elements;
   for (let column = 0; column < 16; column += 4) {
     elements[column] -= 2 * x / width * elements[column + 3];
@@ -5674,10 +5619,7 @@ class ProjectedSplats {
   constructor(renderer, uniforms) {
     this.renderer = renderer;
     this.uniforms = uniforms;
-    this.indirect = new webgpu.IndirectStorageBufferAttribute(
-      new Uint32Array([SPLATS_PER_INSTANCE * 6, 0, 0, 0, 0]),
-      1
-    );
+    this.indirect = new webgpu.IndirectStorageBufferAttribute(new Uint32Array(5), 1);
     this.error = null;
     this.cache = new ProjectionCache();
     this.visibleCount = new webgpu.StorageBufferAttribute(new Uint32Array(1), 1);
@@ -5717,7 +5659,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__namespace.Vector2() }
+      projectionJitter: { value: new THREE__namespace.Vector2() },
+      // Indices per instance of the drawn geometry, quads or triangles.
+      indexCount: { value: 0 }
     };
     const count = N__namespace.storage(this.visibleCount, "uint").setName("gslVisibleCount").toReadOnly().element(0);
     this.sorter = new WebGPURadixSort(1, this.keys, {
@@ -5729,13 +5673,16 @@ class ProjectedSplats {
         this.limits.maxBufferSize
       )
     });
-    const drawCount = N__namespace.storage(this.indirect, "uint").setName("gslDrawIndirect").element(1);
+    const drawArgs = N__namespace.storage(this.indirect, "uint").setName(
+      "gslDrawIndirect"
+    );
     const counter = N__namespace.storage(this.visibleCount, "uint").setName("gslVisibleCount").toAtomic();
     this.resetCount = N__namespace.Fn(() => {
       N__namespace.atomicStore(counter.element(0), N__namespace.uint(0));
     })().compute(1, [1]).setName("Splat reset visible count");
     this.finish = N__namespace.Fn(() => {
-      drawCount.assign(
+      drawArgs.element(0).assign(uniformBinding(this.state, "indexCount", "uint"));
+      drawArgs.element(1).assign(
         count.add(SPLATS_PER_INSTANCE - 1).div(N__namespace.uint(SPLATS_PER_INSTANCE))
       );
     })().compute(1, [1]).setName("Splat visible draw arguments");
@@ -5983,10 +5930,11 @@ class ProjectedSplats {
     this.state.sortRadial.value = radial;
     const jitter = this.state.projectionJitter.value;
     jitter.set(0, 0);
-    const unjittered = getTAAProjection(camera);
+    const unjittered = getUnjitteredProjection(camera);
     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;
@@ -5995,6 +5943,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;
@@ -6181,9 +6130,11 @@ class GaussianSplatRenderer extends THREE__namespace.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__namespace.Vector2();
@@ -6287,7 +6238,7 @@ class GaussianSplatRenderer extends THREE__namespace.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() {
@@ -6339,13 +6290,11 @@ class GaussianSplatRenderer extends THREE__namespace.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);
@@ -6896,676 +6845,6 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
 function isOpaqueMaterial(material) {
   return material.transparent === false && material.blending === THREE__namespace.NormalBlending && material.alphaToCoverage === false;
 }
-class StochasticCoverage {
-  constructor() {
-    __publicField(this, "materials", /* @__PURE__ */ new Map());
-  }
-  material(source, renderer) {
-    let entry = this.materials.get(source);
-    if (!entry) {
-      const variant = createStochasticSplatVariant(source, renderer);
-      if (!variant) return source;
-      const dispose = () => {
-        source.removeEventListener("dispose", dispose);
-        variant.dispose();
-        this.materials.delete(source);
-      };
-      entry = { variant, state: new MaterialState(source), dispose };
-      this.materials.set(source, entry);
-      source.addEventListener("dispose", dispose);
-    }
-    entry.state.sync(entry.variant, source);
-    return entry.variant;
-  }
-  render(renderer, scene, camera) {
-    if (!usesNativeWebGPU(renderer) && !renderer.getContext().getExtension("OES_sample_variables"))
-      throw new Error(
-        "Stochastic rendering with MSAA requires OES_sample_variables on WebGL2; use msaa = false on this device"
-      );
-    const nodeRenderer = renderer.isWebGPURenderer === true;
-    const previous = nodeRenderer ? renderer.getRenderObjectFunction() : renderer.renderBufferDirect;
-    const draw = previous ?? renderer.renderObject;
-    const materialIndex = nodeRenderer ? 4 : 3;
-    const hook = (...args) => {
-      args[materialIndex] = this.material(args[materialIndex], renderer);
-      return draw.apply(renderer, args);
-    };
-    if (nodeRenderer) renderer.setRenderObjectFunction(hook);
-    else renderer.renderBufferDirect = hook;
-    try {
-      renderer.render(scene, camera);
-    } finally {
-      if (nodeRenderer) renderer.setRenderObjectFunction(previous);
-      else renderer.renderBufferDirect = previous;
-    }
-  }
-  dispose() {
-    for (const entry of this.materials.values()) entry.dispose();
-  }
-}
-const vertexShader$1 = (
-  /* glsl */
-  `
-out vec2 vUv;
-void main() {
-  vUv = uv;
-  gl_Position = vec4(position.xy, 0.0, 1.0);
-}
-`
-);
-const fragmentShader = (
-  /* glsl */
-  `
-precision highp float;
-precision highp int;
-uniform sampler2D source;
-uniform sampler2D sourceDepth;
-uniform sampler2D history;
-uniform sampler2D historyDepth;
-uniform vec2 renderSize;
-uniform mat4 projection;
-uniform mat4 unjitteredProjection;
-uniform mat4 previousProjection;
-uniform mat4 viewToPreviousClip;
-uniform mat4 previousViewToView;
-uniform bool valid;
-uniform bool reversed;
-uniform bool logarithmic;
-uniform vec2 logFar;
-uniform float depthThreshold;
-uniform float edgeDepthDiff;
-uniform float maxMotionLength;
-uniform bool useSubpixelCorrection;
-uniform vec3 luminanceCoefficients;
-in vec2 vUv;
-out vec4 fragColor;
-
-ivec2 bounded(ivec2 p) {
-  return clamp(p, ivec2(0), ivec2(renderSize) - 1);
-}
-
-// Homogeneous view coordinates retain far-depth precision and avoid a
-// world-space round trip.
-vec4 viewPosition(vec2 uv, float depth, mat4 p, float logFarValue) {
-  float z = reversed ? depth : depth * 2.0 - 1.0;
-  float orientation = reversed ? -1.0 : 1.0;
-  float viewZ = (p[3][2] - z * p[3][3]) * orientation;
-  float viewW = (z * p[2][3] - p[2][2]) * orientation;
-  if (logarithmic) {
-    viewZ = 1.0 - exp2(depth * logFarValue);
-    viewW = 1.0;
-  }
-  float clipW = p[2][3] * viewZ + p[3][3] * viewW;
-  vec2 viewXY = ((uv * 2.0 - 1.0) * clipW - p[2].xy * viewZ
-    - p[3].xy * viewW) / vec2(p[0][0], p[1][1]);
-  return vec4(viewXY, viewZ, viewW);
-}
-
-float forwardDepth(vec4 positionView) {
-  vec4 clip = projection * positionView;
-  float depth = clip.z / clip.w;
-  return reversed ? 1.0 - depth : depth * 0.5 + 0.5;
-}
-
-vec4 clipAABB(vec4 center, vec4 historyColor, vec4 extent) {
-  vec4 delta = historyColor - center;
-  vec3 unit = abs(delta.rgb / (extent.rgb + 1e-7));
-  float maxUnit = max(unit.r, max(unit.g, unit.b));
-  return maxUnit > 1.0 ? center + delta / maxUnit : historyColor;
-}
-
-vec4 flickerReduction(vec4 currentColor, vec4 historyColor, float currentWeight) {
-  vec3 compressedCurrent = currentColor.rgb / (max(currentColor.r, max(currentColor.g, currentColor.b)) + 1.0);
-  vec3 compressedHistory = historyColor.rgb / (max(historyColor.r, max(historyColor.g, historyColor.b)) + 1.0);
-  float weightCurrent = currentWeight / (dot(compressedCurrent, luminanceCoefficients) + 1.0);
-  float weightHistory = (1.0 - currentWeight) / (dot(compressedHistory, luminanceCoefficients) + 1.0);
-  return (currentColor * weightCurrent + historyColor * weightHistory)
-    / max(weightCurrent + weightHistory, 0.00001);
-}
-
-void main() {
-  ivec2 pixel = ivec2(gl_FragCoord.xy);
-  vec4 currentColor = texelFetch(source, pixel, 0);
-  fragColor = currentColor;
-  gl_FragDepth = texelFetch(sourceDepth, pixel, 0).r;
-  if (!valid) return;
-
-  float closestDepth = 2.0;
-  float farthestDepth = -1.0;
-  float closestRawDepth = gl_FragDepth;
-  ivec2 closestPixel = pixel;
-  vec4 moment1 = currentColor;
-  vec4 moment2 = currentColor * currentColor;
-  for (int x = -1; x <= 1; ++x) {
-    for (int y = -1; y <= 1; ++y) {
-      ivec2 p = bounded(pixel + ivec2(x, y));
-      float rawDepth = texelFetch(sourceDepth, p, 0).r;
-      float depth = reversed && !logarithmic ? 1.0 - rawDepth : rawDepth;
-      if (depth < closestDepth) {
-        closestDepth = depth;
-        closestRawDepth = rawDepth;
-        closestPixel = p;
-      }
-      farthestDepth = max(farthestDepth, depth);
-      if (x != 0 || y != 0) {
-        vec4 neighbor = max(texelFetch(source, p, 0), vec4(0.0));
-        moment1 += neighbor;
-        moment2 += neighbor * neighbor;
-      }
-    }
-  }
-
-  vec2 closestUV = (vec2(closestPixel) + 0.5) / renderSize;
-  vec4 positionView = viewPosition(closestUV, closestRawDepth, projection, logFar.x);
-  vec4 previousClip = viewToPreviousClip * positionView;
-  if (previousClip.w <= 0.0) return;
-  vec4 currentClip = unjitteredProjection * positionView;
-  // Exclude projection jitter from camera motion.
-  vec2 offsetUV = (currentClip.xy / currentClip.w - previousClip.xy / previousClip.w) * 0.5;
-  vec2 historyUV = vUv - offsetUV;
-  if (any(lessThan(historyUV, vec2(0.0))) || any(greaterThanEqual(historyUV, vec2(1.0)))) return;
-
-  float oldDepth = texture(historyDepth, historyUV).r;
-  vec4 previousView = viewPosition(historyUV, oldDepth, previousProjection, logFar.y);
-  float previousDepth = forwardDepth(previousViewToView * previousView);
-  if (logarithmic) {
-    // Log depth is monotonic; convert only the extrema for depth thresholds.
-    closestDepth = forwardDepth(positionView);
-    float farthestZ = 1.0 - exp2(farthestDepth * logFar.x);
-    farthestDepth = forwardDepth(vec4(0.0, 0.0, farthestZ, 1.0));
-  }
-  bool isEdge = farthestDepth - closestDepth > edgeDepthDiff;
-  bool isDisocclusion = closestDepth - previousDepth > depthThreshold;
-  if (!isEdge && isDisocclusion) return;
-
-  float motionFactor = clamp(length(offsetUV * renderSize) / maxMotionLength, 0.0, 1.0);
-  float currentWeight = 0.05;
-  if (useSubpixelCorrection) {
-    vec2 phase = fract(offsetUV * renderSize);
-    vec2 weight = max(phase, 1.0 - phase);
-    currentWeight += (1.0 - weight.x * weight.y) / 0.75 * 0.25;
-  }
-  currentWeight = clamp(currentWeight + motionFactor, 0.0, 1.0);
-  float gamma = mix(0.5, 1.0, pow(1.0 - motionFactor, 2.0));
-  vec4 mean = moment1 / 9.0;
-  vec4 extent = sqrt(max(moment2 / 9.0 - mean * mean, vec4(0.0))) * gamma;
-  vec4 historyColor = clipAABB(mean, texture(history, historyUV), extent);
-  fragColor = flickerReduction(currentColor, historyColor, currentWeight);
-}
-`
-);
-function makeTarget(name) {
-  const target = new THREE.WebGLRenderTarget(1, 1, {
-    type: THREE.HalfFloatType,
-    depthTexture: new THREE.DepthTexture(1, 1, THREE.FloatType)
-  });
-  target.texture.name = name;
-  return target;
-}
-class TAAPass extends Pass_js.Pass {
-  /** @param msaa Enable 4× MSAA (default false). Fixed for the pass's lifetime. */
-  constructor(scene, camera, msaa = false) {
-    super();
-    this.scene = scene;
-    this.camera = camera;
-    this.msaa = msaa;
-    this._coverage = msaa ? new StochasticCoverage() : null;
-    this.depthThreshold = 5e-4;
-    this.edgeDepthDiff = 1e-3;
-    this.maxMotionLength = 128;
-    this.useSubpixelCorrection = true;
-    this._source = Object.assign(makeTarget("TAAPass.scene"), {
-      isXRRenderTarget: true,
-      samples: msaa ? 4 : 0
-    });
-    this._history = [
-      makeTarget("TAAPass.history0"),
-      makeTarget("TAAPass.history1")
-    ];
-    this._clearColor = new THREE.Color();
-    this._state = createTAAState(
-      (value) => ({ value }),
-      [this._source, ...this._history]
-    );
-    this._uniforms = {
-      source: { value: this._source.texture },
-      sourceDepth: { value: this._source.depthTexture },
-      history: { value: this._history[0].texture },
-      historyDepth: { value: this._history[0].depthTexture },
-      ...this._state.uniforms
-    };
-    this._resolveMaterial = new THREE.ShaderMaterial({
-      name: "TAAPass.resolve",
-      uniforms: this._uniforms,
-      vertexShader: vertexShader$1,
-      fragmentShader,
-      glslVersion: THREE.GLSL3,
-      blending: THREE.NoBlending,
-      depthTest: true,
-      depthWrite: true,
-      toneMapped: false
-    });
-    this._copyMaterial = new THREE.ShaderMaterial({
-      name: "TAAPass.copy",
-      uniforms: { source: { value: null }, decode: { value: false } },
-      vertexShader: vertexShader$1,
-      // Inverts OutputPass's transfer, so the two round-trip at any alpha.
-      fragmentShader: (
-        /* glsl */
-        `
-        uniform sampler2D source;
-        uniform bool decode;
-        in vec2 vUv;
-        out vec4 fragColor;
-        void main() {
-          fragColor = texture(source, vUv);
-          if (decode) {
-            vec4 color = vec4(max(fragColor.rgb, 0.0), 1.0);
-            fragColor.rgb = sRGBTransferEOTF(color).rgb;
-          }
-        }
-      `
-      ),
-      glslVersion: THREE.GLSL3,
-      blending: THREE.NoBlending,
-      depthTest: false,
-      depthWrite: false,
-      toneMapped: false
-    });
-    this._quad = new Pass_js.FullScreenQuad(this._resolveMaterial);
-  }
-  /** Current scene depth, before temporal accumulation. Owned by this pass. */
-  get depthTexture() {
-    return this._source.depthTexture;
-  }
-  /** Jittered projection used to capture depthTexture. Treat as read-only. */
-  get projectionMatrix() {
-    return this._uniforms.projection.value;
-  }
-  /** Resize all internal targets in physical pixels; a size change clears history. */
-  setSize(width, height) {
-    this._state.setSize(width, height);
-  }
-  /** Discard history after a camera cut, scene replacement, or color-space change. */
-  reset() {
-    this._state.reset();
-  }
-  /** Render the scene and resolve TAA into the composer's working-space buffer. */
-  render(renderer, writeBuffer) {
-    var _a2;
-    const { camera, _state: state, _uniforms: uniforms } = this;
-    this.setSize(writeBuffer.width, writeBuffer.height);
-    const colorSpace = renderer.outputColorSpace;
-    if (this._source.texture.colorSpace !== colorSpace) {
-      this._source.texture.colorSpace = colorSpace;
-      this.reset();
-    }
-    state.setStencil(((_a2 = renderer.getContextAttributes()) == null ? void 0 : _a2.stencil) === true);
-    const previousTarget = renderer.getRenderTarget();
-    const autoClear = renderer.autoClear;
-    const xrEnabled = renderer.xr.enabled;
-    const toneMapping = renderer.toneMapping;
-    try {
-      renderer.xr.enabled = false;
-      renderer.autoClear = false;
-      renderer.toneMapping = THREE.NoToneMapping;
-      const reversedDepth = camera.reversedDepth;
-      state.beginCapture(camera);
-      try {
-        renderer.setRenderTarget(this._source);
-        renderer.setClearColor(
-          renderer.getClearColor(this._clearColor),
-          renderer.getClearAlpha()
-        );
-        renderer.clear();
-        if (this._coverage) this._coverage.render(renderer, this.scene, camera);
-        else renderer.render(this.scene, camera);
-      } finally {
-        state.endCapture(camera);
-        if (camera.reversedDepth !== reversedDepth)
-          camera.updateProjectionMatrix();
-      }
-      const input = this._history[state.historyIndex];
-      const output = this._history[1 - state.historyIndex];
-      if (!uniforms.valid.value) {
-        for (const target of this._history) renderer.initRenderTarget(target);
-      }
-      uniforms.history.value = input.texture;
-      uniforms.historyDepth.value = input.depthTexture;
-      uniforms.reversed.value = renderer.capabilities.reversedDepthBuffer;
-      uniforms.logarithmic.value = renderer.capabilities.logarithmicDepthBuffer && "isPerspectiveCamera" in camera && camera.isPerspectiveCamera;
-      this._resolveMaterial.depthFunc = state.prepareResolve(camera, this);
-      renderer.setRenderTarget(output);
-      this._quad.material = this._resolveMaterial;
-      this._quad.render(renderer);
-      this._copyMaterial.uniforms.source.value = output.texture;
-      this._copyMaterial.uniforms.decode.value = !this.renderToScreen && THREE.ColorManagement.getTransfer(colorSpace) === THREE.SRGBTransfer;
-      renderer.setRenderTarget(this.renderToScreen ? null : writeBuffer);
-      this._quad.material = this._copyMaterial;
-      this._quad.render(renderer);
-      state.advance(camera);
-    } finally {
-      renderer.setRenderTarget(previousTarget);
-      renderer.autoClear = autoClear;
-      renderer.xr.enabled = xrEnabled;
-      renderer.toneMapping = toneMapping;
-    }
-  }
-  dispose() {
-    var _a2;
-    (_a2 = this._coverage) == null ? void 0 : _a2.dispose();
-    this._source.dispose();
-    for (const target of this._history) target.dispose();
-    this._resolveMaterial.dispose();
-    this._copyMaterial.dispose();
-    this._quad.dispose();
-  }
-}
-class TAANode extends webgpu.Node {
-  static get type() {
-    return "TAANode";
-  }
-  /** @param msaa Enable 4× MSAA (default false). Fixed for the node's lifetime. */
-  constructor(scene, camera, msaa = false) {
-    super("vec4");
-    this.scene = scene;
-    this.camera = camera;
-    this.msaa = msaa;
-    this.coverage = msaa ? new StochasticCoverage() : null;
-    this.depthThreshold = 5e-4;
-    this.edgeDepthDiff = 1e-3;
-    this.maxMotionLength = 128;
-    this.useSubpixelCorrection = true;
-    this.source = this.makeTarget("TAA.scene");
-    this.source.samples = msaa ? 4 : 0;
-    this.source.storeMultisampledColorBuffer = false;
-    this.history = [
-      this.makeTarget("TAA.history0"),
-      this.makeTarget("TAA.history1")
-    ];
-    this.historyColor = N__namespace.texture(this.history[0].texture, N__namespace.screenUV);
-    this.historyDepth = N__namespace.texture(this.history[0].depthTexture, N__namespace.screenUV);
-    this.textureNode = N__namespace.passTexture(this, this.history[0].texture);
-    this.material = new webgpu.NodeMaterial();
-    this.quad = new webgpu.QuadMesh(this.material);
-    this.state = createTAAState(
-      N__namespace.uniform,
-      [this.source, ...this.history],
-      true
-    );
-    this.zeroToOne = N__namespace.uniform(true);
-    this.drawingSize = new THREE.Vector2();
-    this.workingColorSpace = THREE.ColorManagement.workingColorSpace;
-    this.pipelineStates = /* @__PURE__ */ new WeakSet();
-    this.pipelineRendering = false;
-    this.capturePending = true;
-    this.updateBeforeType = webgpu.NodeUpdateType.RENDER;
-    this.material.name = "TAA.resolve";
-    this.material.blending = THREE.NoBlending;
-    this.material.depthTest = true;
-    this.material.depthWrite = true;
-    this.material.toneMapped = false;
-    this.quad.name = "TAA.resolve";
-  }
-  makeTarget(name) {
-    const target = new webgpu.RenderTarget(1, 1, {
-      type: THREE.HalfFloatType,
-      depthTexture: new THREE.DepthTexture(1, 1, THREE.FloatType),
-      samples: 0
-    });
-    target.texture.name = name;
-    return target;
-  }
-  get depthTexture() {
-    return this.source.depthTexture;
-  }
-  get projectionMatrix() {
-    return this.state.uniforms.projection.value;
-  }
-  getTextureNode() {
-    return this.textureNode;
-  }
-  setSize(width, height) {
-    this.state.setSize(width, height);
-  }
-  reset() {
-    this.state.reset();
-  }
-  updateBefore(frame) {
-    if (this.pipelineRendering && !this.capturePending) return;
-    const renderer = frame.renderer;
-    if (this.workingColorSpace !== THREE.ColorManagement.workingColorSpace) {
-      this.workingColorSpace = THREE.ColorManagement.workingColorSpace;
-      this.reset();
-    }
-    const rendererState = webgpu.RendererUtils.saveRendererState(renderer);
-    const xrEnabled = renderer.xr.enabled;
-    const { camera, state } = this;
-    const { uniforms } = state;
-    if (this.pipelineRendering) {
-      this.setSize(this.drawingSize.x, this.drawingSize.y);
-    } else if (rendererState.renderTarget) {
-      this.setSize(
-        rendererState.renderTarget.width,
-        rendererState.renderTarget.height
-      );
-    } else {
-      renderer.getDrawingBufferSize(this.drawingSize);
-      this.setSize(this.drawingSize.x, this.drawingSize.y);
-    }
-    state.setStencil(renderer.stencil);
-    try {
-      renderer.xr.enabled = false;
-      renderer.setMRT(null);
-      renderer.setScissorTest(false);
-      renderer.autoClear = true;
-      const reversedDepth = camera.reversedDepth;
-      const coordinateSystem = camera.coordinateSystem;
-      state.beginCapture(camera);
-      try {
-        renderer.setRenderTarget(this.source);
-        if (this.coverage) this.coverage.render(renderer, this.scene, camera);
-        else renderer.render(this.scene, camera);
-      } finally {
-        state.endCapture(camera);
-        if (camera.reversedDepth !== reversedDepth || camera.coordinateSystem !== coordinateSystem)
-          camera.updateProjectionMatrix();
-      }
-      uniforms.reversed.value = renderer.reversedDepthBuffer;
-      this.zeroToOne.value = renderer.coordinateSystem !== THREE.WebGLCoordinateSystem || renderer.reversedDepthBuffer;
-      uniforms.logarithmic.value = renderer.logarithmicDepthBuffer && "isPerspectiveCamera" in camera && camera.isPerspectiveCamera;
-      this.material.depthFunc = state.prepareResolve(camera, this);
-      if (!uniforms.valid.value)
-        for (const target of this.history) renderer.initRenderTarget(target);
-      const previous = this.history[state.historyIndex];
-      this.historyColor.value = previous.texture;
-      this.historyDepth.value = previous.depthTexture;
-      const output = this.history[1 - state.historyIndex];
-      renderer.setRenderObjectFunction(null);
-      renderer.setRenderTarget(output);
-      this.quad.render(renderer);
-      this.textureNode.value = output.texture;
-      state.advance(camera);
-      this.capturePending = false;
-    } finally {
-      webgpu.RendererUtils.restoreRendererState(renderer, rendererState);
-      renderer.xr.enabled = xrEnabled;
-    }
-    return void 0;
-  }
-  setup(builder) {
-    applyThreeR186Patch(builder.renderer);
-    const pipelineState = builder.context.renderPipelineState;
-    if (pipelineState && !this.pipelineStates.has(pipelineState)) {
-      this.pipelineStates.add(pipelineState);
-      const begin = () => {
-        this.pipelineRendering = true;
-        this.capturePending = true;
-        const renderer = builder.renderer;
-        const target = renderer.getRenderTarget() ?? renderer.getOutputRenderTarget();
-        if (target) this.drawingSize.set(target.width, target.height);
-        else renderer.getDrawingBufferSize(this.drawingSize);
-      };
-      begin();
-      N__namespace.OnBeforeRenderPipeline(begin);
-      N__namespace.OnAfterRenderPipeline(() => {
-        this.pipelineRendering = false;
-      });
-    }
-    const u = this.state.uniforms;
-    const source = N__namespace.texture(this.source.texture, N__namespace.screenUV);
-    const sourceDepth = N__namespace.texture(this.depthTexture, N__namespace.screenUV);
-    const history = this.historyColor;
-    const historyDepth = this.historyDepth;
-    const bounded = (p) => p.clamp(N__namespace.ivec2(0), N__namespace.ivec2(u.renderSize).sub(1));
-    const viewPosition = (uv, depth2, p, far, near) => {
-      const z = N__namespace.select(this.zeroToOne, depth2, depth2.mul(2).sub(1));
-      const orientation = N__namespace.select(u.reversed, -1, 1);
-      const viewZ = p.element(3).z.sub(z.mul(p.element(3).w)).mul(orientation).toVar();
-      const viewW = z.mul(p.element(2).w).sub(p.element(2).z).mul(orientation).toVar();
-      N__namespace.If(u.logarithmic, () => {
-        viewZ.assign(near.mul(depth2.mul(far).exp2()).negate());
-        viewW.assign(1);
-      });
-      const clipW = p.element(2).w.mul(viewZ).add(p.element(3).w.mul(viewW));
-      const xy = uv.mul(2).sub(1).mul(N__namespace.vec2(1, -1)).mul(clipW).sub(p.element(2).xy.mul(viewZ)).sub(p.element(3).xy.mul(viewW)).div(N__namespace.vec2(p.element(0).x, p.element(1).y));
-      return N__namespace.vec4(xy, viewZ, viewW);
-    };
-    const forwardDepth = (position) => {
-      const clip = u.projection.mul(position).toVar();
-      const depth2 = clip.z.div(clip.w);
-      return N__namespace.select(
-        u.reversed,
-        N__namespace.float(1).sub(depth2),
-        N__namespace.select(this.zeroToOne, depth2, depth2.mul(0.5).add(0.5))
-      );
-    };
-    const pixel = N__namespace.ivec2(N__namespace.screenCoordinate.xy);
-    this.material.depthNode = sourceDepth.load(pixel).r;
-    this.material.colorNode = N__namespace.Fn(() => {
-      const currentColor = source.load(pixel).toVar();
-      const result = currentColor.toVar();
-      N__namespace.If(u.valid, () => {
-        const closestDepth = N__namespace.float(2).toVar();
-        const farthestDepth = N__namespace.float(-1).toVar();
-        const closestRawDepth = sourceDepth.load(pixel).r.toVar();
-        const closestPixel = pixel.toVar();
-        const moment1 = currentColor.toVar();
-        const moment2 = currentColor.mul(currentColor).toVar();
-        for (let x = -1; x <= 1; x++) {
-          for (let y = -1; y <= 1; y++) {
-            const p = bounded(pixel.add(N__namespace.ivec2(x, y))).toVar();
-            const rawDepth = sourceDepth.load(p).r.toVar();
-            const depth2 = N__namespace.select(
-              u.reversed.and(u.logarithmic.not()),
-              N__namespace.float(1).sub(rawDepth),
-              rawDepth
-            ).toVar();
-            N__namespace.If(depth2.lessThan(closestDepth), () => {
-              closestDepth.assign(depth2);
-              closestRawDepth.assign(rawDepth);
-              closestPixel.assign(p);
-            });
-            farthestDepth.assign(farthestDepth.max(depth2));
-            if (x !== 0 || y !== 0) {
-              const neighbor = source.load(p).max(0).toVar();
-              moment1.addAssign(neighbor);
-              moment2.addAssign(neighbor.mul(neighbor));
-            }
-          }
-        }
-        const closestUV = N__namespace.vec2(closestPixel).add(0.5).div(u.renderSize);
-        const positionView = viewPosition(
-          closestUV,
-          closestRawDepth,
-          u.projection,
-          u.logFar.x,
-          u.logNear.x
-        );
-        const previousClip = u.viewToPreviousClip.mul(positionView).toVar();
-        N__namespace.If(previousClip.w.greaterThan(0), () => {
-          const currentClip = u.unjitteredProjection.mul(positionView).toVar();
-          const offsetUV = currentClip.xy.div(currentClip.w).sub(previousClip.xy.div(previousClip.w)).mul(N__namespace.vec2(0.5, -0.5)).toVar();
-          const historyUV = N__namespace.screenUV.sub(offsetUV).toVar();
-          N__namespace.If(
-            historyUV.greaterThanEqual(0).all().and(historyUV.lessThan(1).all()),
-            () => {
-              const oldDepth = historyDepth.sample(historyUV).r.toVar();
-              const previousView = viewPosition(
-                historyUV,
-                oldDepth,
-                u.previousProjection,
-                u.logFar.y,
-                u.logNear.y
-              );
-              const previousDepth = forwardDepth(
-                u.previousViewToView.mul(previousView)
-              );
-              N__namespace.If(u.logarithmic, () => {
-                closestDepth.assign(forwardDepth(positionView));
-                const farthestZ = u.logNear.x.mul(farthestDepth.mul(u.logFar.x).exp2()).negate();
-                farthestDepth.assign(forwardDepth(N__namespace.vec4(0, 0, farthestZ, 1)));
-              });
-              const isEdge = farthestDepth.sub(closestDepth).greaterThan(u.edgeDepthDiff);
-              const isDisocclusion = closestDepth.sub(previousDepth).greaterThan(u.depthThreshold);
-              N__namespace.If(isEdge.or(isDisocclusion.not()), () => {
-                const motionFactor = offsetUV.mul(u.renderSize).length().div(u.maxMotionLength).clamp(0, 1).toVar();
-                const currentWeight = N__namespace.float(0.05).toVar();
-                N__namespace.If(u.useSubpixelCorrection, () => {
-                  const phase = offsetUV.mul(u.renderSize).fract();
-                  const weight = phase.max(N__namespace.vec2(1).sub(phase));
-                  currentWeight.addAssign(
-                    N__namespace.float(1).sub(weight.x.mul(weight.y)).div(0.75).mul(0.25)
-                  );
-                });
-                currentWeight.assign(
-                  currentWeight.add(motionFactor).clamp(0, 1)
-                );
-                const gamma = N__namespace.mix(
-                  0.5,
-                  1,
-                  N__namespace.float(1).sub(motionFactor).pow(2)
-                );
-                const mean = moment1.div(9).toVar();
-                const extent = moment2.div(9).sub(mean.mul(mean)).max(0).sqrt().mul(gamma);
-                const historyColor = history.sample(historyUV).toVar();
-                const delta = historyColor.sub(mean).toVar();
-                const unit = delta.rgb.div(extent.rgb.add(1e-7)).abs();
-                const maxUnit = unit.x.max(unit.y).max(unit.z);
-                N__namespace.If(maxUnit.greaterThan(1), () => {
-                  historyColor.assign(mean.add(delta.div(maxUnit)));
-                });
-                const compressedCurrent = currentColor.rgb.div(
-                  currentColor.r.max(currentColor.g).max(currentColor.b).add(1)
-                );
-                const compressedHistory = historyColor.rgb.div(
-                  historyColor.r.max(historyColor.g).max(historyColor.b).add(1)
-                );
-                const weightCurrent = currentWeight.div(
-                  compressedCurrent.dot(u.luminanceCoefficients).add(1)
-                );
-                const weightHistory = N__namespace.float(1).sub(currentWeight).div(compressedHistory.dot(u.luminanceCoefficients).add(1));
-                result.assign(
-                  currentColor.mul(weightCurrent).add(historyColor.mul(weightHistory)).div(weightCurrent.add(weightHistory).max(1e-5))
-                );
-              });
-            }
-          );
-        });
-      });
-      return result;
-    })();
-    return this.textureNode;
-  }
-  dispose() {
-    var _a2;
-    super.dispose();
-    (_a2 = this.coverage) == null ? void 0 : _a2.dispose();
-    this.source.dispose();
-    for (const target of this.history) target.dispose();
-    this.material.dispose();
-  }
-}
 const types = {
   f32: "float",
   i32: "int",
@@ -7811,6 +7090,17 @@ fn chroma(c: vec3f) -> vec2f {
 fn silu(x: vec4f) -> vec4f { return x / (1.0 + exp(-x)); }
 fn sigmoid(x: f32) -> f32 { return 1.0 / (1.0 + exp(-x)); }`
 );
+const CATMULL_ROM_WEIGHTS = (
+  /* wgsl */
+  `
+  let center: vec2f = floor(position - 0.5) + 0.5;
+  let t: vec2f = position - center;
+  let w0: vec2f = t * (-0.5 + t * (1.0 - 0.5 * t));
+  let w1: vec2f = 1.0 + t * t * (-2.5 + 1.5 * t);
+  let w2: vec2f = t * (0.5 + t * (2.0 - 1.5 * t));
+  let w3: vec2f = t * t * (-0.5 + 0.5 * t);
+  let w12: vec2f = w1 + w2;`
+);
 const PARAMS = (
   /* wgsl */
   `
@@ -7835,6 +7125,7 @@ struct Params {
   cameraStill: f32,    // unchanged view and projection; history stays on the same pixel
   offset: vec2f,       // where in its target the scene was drawn
   colorOffset: vec2f,  // zero after encoding, otherwise the scene's offset
+  jitter: vec2f,       // where this frame's samples lie, in pixels from pixel centres
 };
 @group(0) @binding(0) var<uniform> P: Params;
 @group(0) @binding(1) var linearSampler: sampler;
@@ -7904,13 +7195,7 @@ struct Resampled {
 };
 fn catmullRomSpan(image: texture_2d<f32>, uv: vec2f) -> Resampled {
   let position: vec2f = uv * P.size;
-  let center: vec2f = floor(position - 0.5) + 0.5;
-  let t: vec2f = position - center;
-  let w0: vec2f = t * (-0.5 + t * (1.0 - 0.5 * t));
-  let w1: vec2f = 1.0 + t * t * (-2.5 + 1.5 * t);
-  let w2: vec2f = t * (0.5 + t * (2.0 - 1.5 * t));
-  let w3: vec2f = t * t * (-0.5 + 0.5 * t);
-  let w12: vec2f = w1 + w2;
+${CATMULL_ROM_WEIGHTS}
   let p0: vec2f = (center - 1.0) * P.invSize;
   let p12: vec2f = (center + w2 / w12) * P.invSize;
   let p3: vec2f = (center + 2.0) * P.invSize;
@@ -7933,75 +7218,6 @@ fn catmullRomSpan(image: texture_2d<f32>, uv: vec2f) -> Resampled {
 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;
-  // All three histories share these 2D tap weights and their normalization.
-  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 = (
@@ -8331,15 +7547,60 @@ ${robust ? `  let under: vec4f = coarse(below, position.xy, 2.0);
     groups: groups.length
   };
 }
-const COMPACT_FILTER = (
+const MEAN_3X3 = (
   /* wgsl */
   `
-// Exact clamped 3x3 mean, using bilinear pairs on each axis.
-fn compactFiltered(p: vec2f) -> vec4f {
-  return (4.0 * frameSample(colorTexture, p - vec2f(0.5)) +
-    2.0 * frameSample(colorTexture, p + vec2f(1.0, -0.5)) +
-    2.0 * frameSample(colorTexture, p + vec2f(-0.5, 1.0)) +
-    frameSample(colorTexture, p + vec2f(1.0))) / 9.0;
+// Exact clamped 3x3 mean at a subpixel position, from four bilinear taps.
+// Each axis has weights (1 - t, 1, 1, t) / 3 over four texels. Pair the
+// first two and the last two, moving each tap with its pair's weights.
+fn mean3x3(image: texture_2d<f32>, position: vec2f, offset: vec2f) -> vec4f {
+  let center: vec2f = floor(position - 0.5) + 0.5;
+  let t: vec2f = position - center;
+  let low: vec2f = 2.0 - t;
+  let high: vec2f = 1.0 + t;
+  let size: vec2f = vec2f(textureDimensions(image));
+  let p0: vec2f = (clamp(center - 1.0 + 1.0 / low, vec2f(0.5), P.size - 0.5) + offset) / size;
+  let p1: vec2f = (clamp(center + 1.0 + t / high, vec2f(0.5), P.size - 0.5) + offset) / size;
+  return (textureSampleLevel(image, linearSampler, p0, 0.0) * (low.x * low.y) +
+    textureSampleLevel(image, linearSampler, vec2f(p1.x, p0.y), 0.0) * (high.x * low.y) +
+    textureSampleLevel(image, linearSampler, vec2f(p0.x, p1.y), 0.0) * (low.x * high.y) +
+    textureSampleLevel(image, linearSampler, p1, 0.0) * (high.x * high.y)) / 9.0;
+}
+`
+);
+const QUALITY_RESAMPLING = (
+  /* wgsl */
+  `
+// 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}
+  let p0: vec2f = (center - 1.0) * P.invSize;
+  let p12: vec2f = (center + w2 / w12) * P.invSize;
+  let p3: vec2f = (center + 2.0) * P.invSize;
+  var result: vec4f = textureSampleLevel(image, linearSampler, p12, 0.0) * (w12.x * w12.y);
+  result += textureSampleLevel(image, linearSampler, vec2f(p0.x, p12.y), 0.0) * (w0.x * w12.y);
+  result += textureSampleLevel(image, linearSampler, vec2f(p3.x, p12.y), 0.0) * (w3.x * w12.y);
+  result += textureSampleLevel(image, linearSampler, vec2f(p12.x, p0.y), 0.0) * (w12.x * w0.y);
+  result += textureSampleLevel(image, linearSampler, vec2f(p12.x, p3.y), 0.0) * (w12.x * w3.y);
+  result += textureSampleLevel(image, linearSampler, p0, 0.0) * (w0.x * w0.y);
+  result += textureSampleLevel(image, linearSampler, vec2f(p3.x, p0.y), 0.0) * (w3.x * w0.y);
+  result += textureSampleLevel(image, linearSampler, vec2f(p0.x, p3.y), 0.0) * (w0.x * w3.y);
+  result += textureSampleLevel(image, linearSampler, p3, 0.0) * (w3.x * w3.y);
+  return result / ((w0.x + w12.x + w3.x) * (w0.y + w12.y + w3.y));
+}
+
+// Catmull-Rom of the frame at a position between its pixels, from the five
+// bilinear taps catmullRomSpan takes, read through the scene's offset.
+fn frameCatmullRom(position: vec2f) -> vec4f {
+${CATMULL_ROM_WEIGHTS}
+  let p12: vec2f = center + w2 / w12;
+  var result: vec4f = frameSample(colorTexture, p12) * (w12.x * w12.y);
+  result += frameSample(colorTexture, vec2f(center.x - 1.0, p12.y)) * (w0.x * w12.y);
+  result += frameSample(colorTexture, vec2f(center.x + 2.0, p12.y)) * (w3.x * w12.y);
+  result += frameSample(colorTexture, vec2f(p12.x, center.y - 1.0)) * (w12.x * w0.y);
+  result += frameSample(colorTexture, vec2f(p12.x, center.y + 2.0)) * (w12.x * w3.y);
+  return result / (w12.x * w12.y + (w0.x + w3.x) * w12.y + w12.x * (w0.y + w3.y));
 }
 `
 );
@@ -8382,7 +7643,7 @@ fn blockFiltered(block: vec2i, color: vec4f) -> vec4f {
       sum += wx * wy * frameSample(colorTexture, c + vec2f(f32(x), f32(y)) * (11.0 / 6.0));
     }
   }
-  return mix(color, sum, 0.5);
+  return mix(color, sum, ${float(weights.compactMix[1])});
 }
 `
   ) : (
@@ -8628,7 +7889,7 @@ ${groups.map(
 // half-resolution result.
 @group(0) @binding(11) var wideTexture: texture_2d<f32>;
 @group(0) @binding(12) var depthPrevious: texture_2d<f32>;
-${weights.compact ? COMPACT_FILTER : ""}${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}
@@ -8661,8 +7922,8 @@ struct Output {
 };
 @fragment fn fragment(@builtin(position) position: vec4f) -> Output {
   let p: vec2i = vec2i(position.xy);
-  let d: vec4f = ${weights.compact ? "mix(frameLoad(colorTexture, p), compactFiltered(position.xy), 0.5)" : "textureLoad(filteredTexture, p, 0)"};
   let color: vec4f = frameLoad(colorTexture, p);
+${weights.compact ? "" : "  let d: vec4f = textureLoad(filteredTexture, p, 0);"}
   var sr: vec4f = vec4f(0.0);
   var dr: vec4f = vec4f(0.0);
   // Second moment of luma, the two history lengths, slow low-pass luma.
@@ -8707,14 +7968,14 @@ struct Output {
       a = textureLoad(previousAux, p, 0);
       previous.value = textureLoad(previousOutput, p, 0);
     } else {
-${weights.compact ? `      sr = max(textureSampleLevel(previousAccumulated, linearSampler, h.uv, 0.0), vec4f(0.0));
-      dr = max(textureSampleLevel(previousDenoised, linearSampler, h.uv, 0.0), vec4f(0.0));
-      a = previousStatistics(h.uv);
-      // Reuse the sharp display history already read for its clamp span.` : `      let interpolation: LanczosKernel = lanczosKernel(h.uv);
-      sr = max(lanczosCross(previousAccumulated, interpolation), vec4f(0.0));
-      dr = max(lanczosCross(previousDenoised, interpolation), vec4f(0.0));
+${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));` : `      // 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);
-      previous.value = lanczosCross(previousOutput, interpolation);`}
     }
     // Where a block has no depth of its own, where to read its history is a
     // guess, so while the camera moves it keeps little of the accumulated
@@ -8725,6 +7986,17 @@ ${weights.compact ? `      sr = max(textureSampleLevel(previousAccumulated, line
   }
   ${weights.correction ? "var" : "let"} trust: vec4f = coarse(trustBlocks, position.xy, 4.0) * valid * same;
   ${weights.correction ? "var" : "let"} strength: f32 = coarse(strengthBlocks, position.xy, 4.0).r;
+${weights.compact ? `  // A frame drawn with projection jitter shows at pixel p what lies at
+  // p + jitter. Performance reads the frame at p - jitter instead, with one
+  // bilinear tap that also averages up to four samples, and takes its fixed
+  // filter there: the slow luma, the correction and the denoised path see
+  // the frame where it belongs. The filter takes its full share of the 3x3
+  // mean where the view moves or the denoised history is short, and the
+  // smaller one where that history settles, which keeps more detail.
+  let unjittered: vec2f = position.xy - P.jitter;
+  let shifted: vec4f = frameSample(colorTexture, unjittered);
+  let fullShare: f32 = max(speed * speed / (speed * speed + ${float(weights.movingKnee * weights.movingKnee)}), exp(-aux.z * trust.y / ${float(weights.reach)}));
+  let d: vec4f = mix(shifted, mean3x3(colorTexture, unjittered, P.colorOffset), mix(${float(weights.compactMix[0])}, ${float(weights.compactMix[1])}, fullShare));` : ""}
 ${weights.correction ? `  let corrected: vec4f = correctedPixels(color, d, sr, dr, aux, trust, strength);
   trust = vec4f(corrected.xy, trust.z, corrected.z);
   strength = corrected.w;` : ""}
@@ -8752,7 +8024,19 @@ ${weights.correction ? `  let corrected: vec4f = correctedPixels(color, d, sr, d
   // nothing, which the learned filter leaves standing at any camera speed.
   let short: f32 = max(exp(-wh / ${float(weights.reach)}) * max(fast, sparse), 1.0 - same);` : `let short: f32 = max(exp(-wh / ${float(weights.reach)}) * fast, 1.0 - same);`}
   let wide: vec4f = ${weights.compact ? "mix(coarse(wideTexture, position.xy, 2.0), coarse(rejectedTexture, position.xy, 4.0), 0.5)" : "coarse(wideTexture, position.xy, 2.0)"};
-  var current: vec4f = mix(mix(color, d, strength), wide, short);
+${weights.compact ? `  let source: vec4f = shifted;
+  let filtered: vec4f = d;` : `  // A frame drawn with projection jitter shows at pixel p what lies at
+  // p + jitter. Where history is short the denoised path carries the frame,
+  // and moving content would shift back and forth by up to half a pixel: the
+  // path reads the frame and its filtered image at p - jitter instead.
+  var source: vec4f = color;
+  var filtered: vec4f = d;
+  if (P.jitter.x != 0.0 || P.jitter.y != 0.0) {
+    let unjittered: vec2f = position.xy - P.jitter;
+    source = frameCatmullRom(unjittered);
+    filtered = catmullRom(filteredTexture, unjittered * P.invSize);
+  }`}
+  var current: vec4f = mix(mix(source, filtered, strength), wide, short);
   // Strengthen only the share whose history belonged to another surface.
   // Normal fast motion keeps the learned fallback's detail.
   let rejected: vec4f = coarse(rejectedTexture, position.xy, 4.0);
@@ -9312,7 +8596,7 @@ P.historyValid = ndUniform7.z; P.stabilize = ndUniform7.w;
 P.halfBias = ndUniform8.x; P.logDepth = ndUniform8.y;
 P.logNear = ndUniform8.z; P.logFar = ndUniform8.w;
 P.turn = ndUniform9.x; P.cameraStill = ndUniform9.y; P.offset = ndUniform9.zw;
-P.colorOffset = ndUniform10.xy;
+P.colorOffset = ndUniform10.xy; P.jitter = ndUniform10.zw;
 `
 );
 class WebGLDenoisePasses extends NeuralDenoisePasses {
@@ -9390,6 +8674,7 @@ class WebGLDenoisePasses extends NeuralDenoisePasses {
   }
   allocate(views, depth2) {
     var _a2, _b;
+    if (depth2) depth2.texture.renderTarget = null;
     const target = new this.Target(
       ((_a2 = views[0]) == null ? void 0 : _a2.width) ?? this.width,
       ((_b = views[0]) == null ? void 0 : _b.height) ?? this.height,
@@ -9563,6 +8848,7 @@ const quality = {
   denoisedFrames: 24,
   gateFrames: 8,
   motionKnee: 20,
+  movingKnee: 0.5,
   stabilizeBlend: 0.9,
   stabilizeSlack: 0.04,
   evidenceFrames: [3, 6, 12, 24],
@@ -11603,8 +10889,55 @@ const quality = {
 };
 const neuralDenoiseModels = {
   quality,
-  performance: { ...quality, compact: true }
+  performance: { ...quality, compact: true, compactMix: [0.5, 0.75] }
 };
+class StochasticCoverage {
+  constructor() {
+    __publicField(this, "materials", /* @__PURE__ */ new Map());
+  }
+  material(source, renderer) {
+    let entry = this.materials.get(source);
+    if (!entry) {
+      const variant = createStochasticSplatVariant(source, renderer);
+      if (!variant) return source;
+      const dispose = () => {
+        source.removeEventListener("dispose", dispose);
+        variant.dispose();
+        this.materials.delete(source);
+      };
+      entry = { variant, state: new MaterialState(source), dispose };
+      this.materials.set(source, entry);
+      source.addEventListener("dispose", dispose);
+    }
+    entry.state.sync(entry.variant, source);
+    return entry.variant;
+  }
+  render(renderer, scene, camera) {
+    if (!usesNativeWebGPU(renderer) && !renderer.getContext().getExtension("OES_sample_variables"))
+      throw new Error(
+        "Stochastic rendering with MSAA requires OES_sample_variables on WebGL2; use msaa = false on this device"
+      );
+    const nodeRenderer = renderer.isWebGPURenderer === true;
+    const previous = nodeRenderer ? renderer.getRenderObjectFunction() : renderer.renderBufferDirect;
+    const draw = previous ?? renderer.renderObject;
+    const materialIndex = nodeRenderer ? 4 : 3;
+    const hook = (...args) => {
+      args[materialIndex] = this.material(args[materialIndex], renderer);
+      return draw.apply(renderer, args);
+    };
+    if (nodeRenderer) renderer.setRenderObjectFunction(hook);
+    else renderer.renderBufferDirect = hook;
+    try {
+      renderer.render(scene, camera);
+    } finally {
+      if (nodeRenderer) renderer.setRenderObjectFunction(previous);
+      else renderer.renderBufferDirect = previous;
+    }
+  }
+  dispose() {
+    for (const entry of this.materials.values()) entry.dispose();
+  }
+}
 const MARGIN = 3;
 const VIEW_OFFSETS = [
   [2, 2],
@@ -11662,12 +10995,7 @@ class NeuralDenoiseNode extends webgpu.Node {
       });
       return color;
     })());
-    __publicField(this, "state", createTAAState(
-      (value) => ({ value }),
-      [this.source, ...this.history],
-      true,
-      MARGIN
-    ));
+    __publicField(this, "state", createNeuralDenoiseState([this.source, ...this.history], MARGIN));
     __publicField(this, "passes", null);
     // The scene target's depth has the margin; this one has the image's size.
     __publicField(this, "depth", new THREE.DepthTexture(1, 1, THREE.FloatType));
@@ -11705,7 +11033,7 @@ class NeuralDenoiseNode extends webgpu.Node {
   }
   /** The projection `depthTexture` was rendered with. */
   get projectionMatrix() {
-    return this.state.uniforms.projection.value;
+    return this.state.projection;
   }
   /** The denoised image, for chaining effects. */
   getTextureNode() {
@@ -11773,7 +11101,7 @@ class NeuralDenoiseNode extends webgpu.Node {
       renderer.toneMapping = THREE.NoToneMapping;
       const reversedDepth = camera.reversedDepth;
       const coordinateSystem = camera.coordinateSystem;
-      const { x: width, y: height } = state.uniforms.renderSize.value;
+      const { x: width, y: height } = state.size;
       const [offsetX, offsetY] = VIEW_OFFSETS[Math.floor(this.frame / 32) % VIEW_OFFSETS.length];
       this.frame++;
       this.source.viewport.set(offsetX, offsetY, width, height);
@@ -11787,11 +11115,11 @@ class NeuralDenoiseNode extends webgpu.Node {
         if (camera.reversedDepth !== reversedDepth || camera.coordinateSystem !== coordinateSystem)
           camera.updateProjectionMatrix();
       }
-      const valid = state.uniforms.valid.value;
+      const valid = state.valid;
       if (!valid && native)
         for (const target of this.history) renderer.initRenderTarget(target);
       const u = passes.uniforms;
-      const jittered = state.uniforms.projection.value.elements;
+      const jittered = state.projection.elements;
       const logarithmic = (nodeRenderer ? renderer.logarithmicDepthBuffer : renderer.capabilities.logarithmicDepthBuffer) && "isPerspectiveCamera" in camera && camera.isPerspectiveCamera;
       const near = Math.max(camera.near, 1e-6);
       const reversed = nodeRenderer ? renderer.reversedDepthBuffer : renderer.capabilities.reversedDepthBuffer;
@@ -11833,6 +11161,17 @@ class NeuralDenoiseNode extends webgpu.Node {
         this.source.texture.colorSpace || this.workingColorSpace
       ) === THREE.LinearTransfer;
       u.set(encode ? [0, 0] : [u[62], u[63]], 64);
+      const p = camera.projectionMatrix.elements;
+      let jitterX = 0;
+      let jitterY = 0;
+      if ([8, 9, 12, 13].some((i) => jittered[i] !== p[i])) {
+        const x = (jittered[8] - jittered[12]) / jittered[0];
+        const y = (jittered[9] - jittered[13]) / jittered[5];
+        const w = p[3] * x + p[7] * y - p[11] + p[15];
+        jitterX = (p[0] * x + p[4] * y - p[8] + p[12]) / w * width / 2;
+        jitterY = -((p[1] * x + p[5] * y - p[9] + p[13]) / w) * height / 2;
+      }
+      u.set([jitterX, jitterY], 66);
       this.encoded.value = THREE.ColorManagement.getTransfer(this.workingColorSpace) === THREE.LinearTransfer;
       const gpu = (texture) => {
         const data = backend.get(texture).texture;
@@ -11865,7 +11204,7 @@ class NeuralDenoiseNode extends webgpu.Node {
       this.textureNode.value = native ? this.history[1 - previous].texture : passes.result;
       this.previousWorld.copy(camera.matrixWorld);
       this.previousProjection.copy(camera.projectionMatrix);
-      state.advance(camera);
+      state.advance();
       this.capturePending = false;
     } finally {
       renderer.setRenderTarget(
@@ -11950,7 +11289,7 @@ void main() {
   vec4 color = texture2D(image, vUv);
   if (encoded) {
     // OutputPass applies its transfer directly to premultiplied RGB. Invert
-    // that transfer here, as TAAPass does, to round-trip transparent pixels.
+    // that transfer here to round-trip transparent pixels.
     float scale = outputSRGB ? 1.0 : max(color.a, 1e-6);
     color.rgb = sRGBTransferEOTF(vec4(max(color.rgb / scale, 0.0), 1.0)).rgb * scale;
   }
@@ -12024,6 +11363,175 @@ void main() {
     this.quad.dispose();
   }
 }
+const EYE_PATTERN_OFFSET = 16;
+class NeuralDenoiseXR {
+  constructor(renderer, scene, camera, mode = "quality", msaa = false) {
+    __publicField(this, "stabilize", true);
+    __publicField(this, "views", []);
+    __publicField(this, "output", null);
+    assertSupportedRenderer(renderer);
+    this.renderer = renderer;
+    this.scene = scene;
+    this.camera = camera;
+    this.mode = mode;
+    this.msaa = msaa;
+    this.nodeRenderer = isWebGPURenderer(renderer);
+    if (this.nodeRenderer) applyThreeR186Patch(renderer);
+    this.onSessionEnd = () => this.disposeViews();
+    renderer.xr.addEventListener("sessionend", this.onSessionEnd);
+  }
+  createViews(eyes) {
+    this.disposeViews();
+    this.views = eyes.map((eye) => {
+      const camera = new THREE.PerspectiveCamera();
+      const pass = this.nodeRenderer ? new NeuralDenoiseNode(this.scene, camera, this.mode, this.msaa) : new NeuralDenoisePass(this.scene, camera, this.mode, this.msaa);
+      const denoise = this.nodeRenderer ? pass : pass.denoise;
+      denoise.updateBeforeType = webgpu.NodeUpdateType.NONE;
+      return { eye, pass, denoise };
+    });
+    if (this.nodeRenderer) {
+      const material = new webgpu.NodeMaterial();
+      material.name = "NeuralDenoiseXR.output";
+      material.vertexNode = N__namespace.vec4(N__namespace.positionGeometry.xy, 0, 1);
+      const color = N__namespace.Fn((builder) => {
+        const index2 = viewIndex(builder.camera);
+        const color2 = N__namespace.vec4(0).toVar();
+        this.views.forEach((view, i) => {
+          N__namespace.If(index2.equal(i), () => {
+            color2.assign(view.denoise.getTextureNode());
+          });
+        });
+        return color2;
+      })();
+      material.fragmentNode = N__namespace.renderOutput(
+        color,
+        this.renderer.toneMapping,
+        this.renderer.outputColorSpace
+      );
+      material.depthTest = false;
+      material.depthWrite = false;
+      material.blending = THREE.NoBlending;
+      this.output = new webgpu.QuadMesh(material);
+    } else {
+      this.output = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), this.views[0].pass.copy);
+      this.output.onBeforeRender = (renderer, scene, camera) => {
+        const { denoise } = this.views.find((view) => view.eye === camera);
+        const uniforms = this.output.material.uniforms;
+        uniforms.image.value = denoise.textureNode.value;
+        uniforms.encoded.value = denoise.encoded.value;
+        uniforms.outputSRGB.value = THREE.ColorManagement.getTransfer(renderer.outputColorSpace) === THREE.SRGBTransfer;
+        this.output.material.uniformsNeedUpdate = true;
+      };
+    }
+    this.output.frustumCulled = false;
+    this.output.layers.enableAll();
+  }
+  render() {
+    const { renderer } = this;
+    const { xr } = renderer;
+    if (!xr.enabled || !xr.isPresenting) {
+      throw new Error(
+        "NeuralDenoiseXR.render() requires an active WebXR session"
+      );
+    }
+    if (xr.cameraAutoUpdate) {
+      this.camera.updateWorldMatrix(true, false);
+      xr.updateCamera(this.camera);
+    }
+    const eyes = xr.getCamera().cameras;
+    if (eyes.length === 0) return;
+    if (eyes.length !== this.views.length || eyes.some((eye, i) => eye !== this.views[i].eye))
+      this.createViews(eyes);
+    const target = renderer.getRenderTarget();
+    const cubeFace = renderer.getActiveCubeFace();
+    const mipLevel = renderer.getActiveMipmapLevel();
+    const cameraAutoUpdate = xr.cameraAutoUpdate;
+    const autoClear = renderer.autoClear;
+    const toneMapping = renderer.toneMapping;
+    const outputColorSpace = renderer.outputColorSpace;
+    const outputTarget = this.nodeRenderer ? renderer.getOutputRenderTarget() : null;
+    const outputDepth = outputTarget == null ? void 0 : outputTarget.depthBuffer;
+    const samples = /* @__PURE__ */ new Map();
+    this.scene.traverse((object) => {
+      if (object instanceof GaussianSplatRenderer && object.autoAdvanceStochasticSample)
+        samples.set(object, object.stochasticSample + 1 >>> 0);
+    });
+    try {
+      xr.cameraAutoUpdate = false;
+      for (const splat of samples.keys())
+        splat.autoAdvanceStochasticSample = false;
+      for (const [index2, { eye, denoise }] of this.views.entries()) {
+        const { camera } = denoise;
+        for (const [splat, sample] of samples)
+          splat.stochasticSample = sample + index2 * EYE_PATTERN_OFFSET >>> 0;
+        camera.copy(eye, false);
+        camera.matrixAutoUpdate = false;
+        camera.matrixWorldAutoUpdate = false;
+        camera.coordinateSystem = renderer.coordinateSystem;
+        const reversed = this.nodeRenderer ? renderer.reversedDepthBuffer : renderer.capabilities.reversedDepthBuffer;
+        camera._reversedDepth = reversed;
+        if (reversed) {
+          const p = camera.projectionMatrix.elements;
+          const scale = usesNativeWebGPU(renderer) ? 1 : 0.5;
+          for (let i = 0; i < 16; i += 4)
+            p[i + 2] = scale * (p[i + 3] - p[i + 2]);
+          camera.projectionMatrixInverse.copy(camera.projectionMatrix).invert();
+        }
+        denoise.scene = this.scene;
+        denoise.stabilize = this.stabilize;
+        denoise.setSize(eye.viewport.z, eye.viewport.w);
+        renderer.setRenderTarget(denoise.history[0]);
+        denoise.updateBefore({ renderer });
+      }
+      renderer.setRenderTarget(target, cubeFace, mipLevel);
+      if (this.nodeRenderer) {
+        const output = this.output.material.fragmentNode;
+        if (output.getToneMapping() !== toneMapping || output.outputColorSpace !== outputColorSpace) {
+          this.output.material.fragmentNode = N__namespace.renderOutput(
+            output.colorNode,
+            toneMapping,
+            outputColorSpace
+          );
+          this.output.material.needsUpdate = true;
+        }
+        renderer.toneMapping = THREE.NoToneMapping;
+        renderer.outputColorSpace = THREE.ColorManagement.workingColorSpace;
+        if (usesNativeWebGPU(renderer) && (outputTarget == null ? void 0 : outputTarget.useArrayDepthTexture))
+          outputTarget.depthBuffer = true;
+      }
+      renderer.render(this.output, this.camera);
+    } finally {
+      for (const [splat, sample] of samples) {
+        splat.stochasticSample = sample;
+        splat.autoAdvanceStochasticSample = true;
+      }
+      xr.enabled = true;
+      xr.cameraAutoUpdate = cameraAutoUpdate;
+      renderer.autoClear = autoClear;
+      renderer.toneMapping = toneMapping;
+      renderer.outputColorSpace = outputColorSpace;
+      if (outputTarget) outputTarget.depthBuffer = outputDepth;
+      renderer.setRenderTarget(target, cubeFace, mipLevel);
+    }
+  }
+  /** Discards both eyes' history after a camera cut or scene replacement. */
+  reset() {
+    for (const { denoise } of this.views) denoise.reset();
+  }
+  disposeViews() {
+    for (const { pass } of this.views) pass.dispose();
+    this.views = [];
+    if (this.output) {
+      if (this.nodeRenderer) this.output.material.dispose();
+      else this.output.geometry.dispose();
+      this.output = null;
+    }
+  }
+  dispose() {
+    this.renderer.xr.removeEventListener("sessionend", this.onSessionEnd);
+    this.disposeViews();
+  }
+}
 class WebGLCapture {
   constructor(renderer) {
     this.renderer = renderer;
@@ -17353,6 +16861,7 @@ const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
 exports.GaussianSplatRenderer = GaussianSplatRenderer;
 exports.NeuralDenoiseNode = NeuralDenoiseNode;
 exports.NeuralDenoisePass = NeuralDenoisePass;
+exports.NeuralDenoiseXR = NeuralDenoiseXR;
 exports.RadStreamScheduler = RadStreamScheduler;
 exports.SogStreamScheduler = SogStreamScheduler;
 exports.SplatCapture = SplatCapture;
@@ -17365,8 +16874,6 @@ exports.SplatFileType = SplatFileType;
 exports.SplatLoader = SplatLoader;
 exports.SplatMesh = SplatMesh;
 exports.Splats = Splats;
-exports.TAANode = TAANode;
-exports.TAAPass = TAAPass;
 exports.defines = defines;
 exports.fromHalf = fromHalf;
 exports.postDecode = postDecode;