gaussian-splat-lite 1.4.0 → 1.4.2

package/dist/types/addons/NeuralDenoiseNode.d.cts

@@ -9,8 +9,7 @@ import { Node, type NodeBuilder, type NodeFrame } from "three/webgpu";
 export type NeuralDenoiseMode = "performance" | "quality";
 /**
  * Experimental temporal neural denoiser for stochastic Splat rendering on WebGPURenderer,
- * including its WebGL2 fallback,
- * used in place of TAANode. After Hu et al., "Ultra-fast Neural Inference for
+ * including its WebGL2 fallback. After Hu et al., "Ultra-fast Neural Inference for
  * Stochastic Gaussian Splatting Denoising" (arXiv 2609.25604), adapted to
  * scenes whose objects move.
  */

package/dist/types/addons/NeuralDenoiseNode.d.ts

@@ -9,8 +9,7 @@ import { Node, type NodeBuilder, type NodeFrame } from "three/webgpu";
 export type NeuralDenoiseMode = "performance" | "quality";
 /**
  * Experimental temporal neural denoiser for stochastic Splat rendering on WebGPURenderer,
- * including its WebGL2 fallback,
- * used in place of TAANode. After Hu et al., "Ultra-fast Neural Inference for
+ * including its WebGL2 fallback. After Hu et al., "Ultra-fast Neural Inference for
  * Stochastic Gaussian Splatting Denoising" (arXiv 2609.25604), adapted to
  * scenes whose objects move.
  */

package/dist/types/addons/NeuralDenoiseXR.d.cts

@@ -0,0 +1,31 @@
+import type { PerspectiveCamera, Scene, WebGLRenderer } from "three";
+import type { WebGPURenderer } from "three/webgpu";
+import type { NeuralDenoiseMode } from "./NeuralDenoiseNode.cjs";
+
+/** Per-eye neural denoising and presentation during an active WebXR session. */
+export declare class NeuralDenoiseXR {
+  readonly renderer: WebGLRenderer | WebGPURenderer;
+  scene: Scene;
+  camera: PerspectiveCamera;
+  readonly mode: NeuralDenoiseMode;
+  readonly msaa: boolean;
+  stabilize: boolean;
+  private views;
+  private output;
+  private readonly nodeRenderer;
+  private readonly onSessionEnd;
+  constructor(
+    renderer: WebGLRenderer | WebGPURenderer,
+    scene: Scene,
+    camera: PerspectiveCamera,
+    mode?: NeuralDenoiseMode,
+    msaa?: boolean,
+  );
+  private createViews;
+  /** Capture, denoise and present each eye during an active XR animation frame. */
+  render(): void;
+  /** Discards both eyes' history after a camera cut or scene replacement. */
+  reset(): void;
+  private disposeViews;
+  dispose(): void;
+}

package/dist/types/addons/NeuralDenoiseXR.d.ts

@@ -0,0 +1,31 @@
+import type { PerspectiveCamera, Scene, WebGLRenderer } from "three";
+import type { WebGPURenderer } from "three/webgpu";
+import type { NeuralDenoiseMode } from "./NeuralDenoiseNode.js";
+
+/** Per-eye neural denoising and presentation during an active WebXR session. */
+export declare class NeuralDenoiseXR {
+  readonly renderer: WebGLRenderer | WebGPURenderer;
+  scene: Scene;
+  camera: PerspectiveCamera;
+  readonly mode: NeuralDenoiseMode;
+  readonly msaa: boolean;
+  stabilize: boolean;
+  private views;
+  private output;
+  private readonly nodeRenderer;
+  private readonly onSessionEnd;
+  constructor(
+    renderer: WebGLRenderer | WebGPURenderer,
+    scene: Scene,
+    camera: PerspectiveCamera,
+    mode?: NeuralDenoiseMode,
+    msaa?: boolean,
+  );
+  private createViews;
+  /** Capture, denoise and present each eye during an active XR animation frame. */
+  render(): void;
+  /** Discards both eyes' history after a camera cut or scene replacement. */
+  reset(): void;
+  private disposeViews;
+  dispose(): void;
+}

package/dist/types/addons/neuralDenoiseState.d.cts

@@ -0,0 +1,22 @@
+import type { Camera, Matrix4, RenderTarget, Vector2 } from "three";
+
+/** Capture sizing, projection jitter and history lifetime for neural denoising. */
+export declare function createNeuralDenoiseState(
+  targets: RenderTarget[],
+  margin: number,
+): {
+  size: Vector2;
+  projection: Matrix4;
+  valid: boolean;
+  historyIndex: number;
+  jitterIndex: number;
+  reset(): void;
+  setSize(width: number, height: number): void;
+  setStencil(stencil: boolean): void;
+  beginCapture(camera: Camera): void;
+  endCapture(camera: Camera): void;
+  advance(): void;
+};
+export declare const getUnjitteredProjection: (
+  camera: Camera,
+) => Matrix4 | undefined;

package/dist/types/addons/neuralDenoiseState.d.ts

@@ -0,0 +1,22 @@
+import type { Camera, Matrix4, RenderTarget, Vector2 } from "three";
+
+/** Capture sizing, projection jitter and history lifetime for neural denoising. */
+export declare function createNeuralDenoiseState(
+  targets: RenderTarget[],
+  margin: number,
+): {
+  size: Vector2;
+  projection: Matrix4;
+  valid: boolean;
+  historyIndex: number;
+  jitterIndex: number;
+  reset(): void;
+  setSize(width: number, height: number): void;
+  setStencil(stencil: boolean): void;
+  beginCapture(camera: Camera): void;
+  endCapture(camera: Camera): void;
+  advance(): void;
+};
+export declare const getUnjitteredProjection: (
+  camera: Camera,
+) => Matrix4 | undefined;

package/dist/types/addons/neuralDenoiseWeights.d.cts

@@ -9,8 +9,22 @@ export type NeuralDenoiseLayer = {
  * Trained on this renderer's stochastic frames.
  */
 export type NeuralDenoiseModel = {
-  /** Use fixed local filtering without learned multiscale passes. */
+  /**
+   * Use fixed local filtering without learned multiscale passes.
+   * Requires `compactMix` and `movingKnee` when true.
+   */
   compact?: boolean;
+  /**
+   * Required with `compact`: shares of the 3x3 mean, each in [0, 1], for
+   * settled denoised history and for camera motion or short history.
+   * The transition uses `movingKnee` and `reach`.
+   */
+  compactMix?: [settled: number, movingOrShort: number];
+  /**
+   * Required with `compact`: positive camera-induced screen motion, in
+   * pixels per frame, at which the motion response is 0.5.
+   */
+  movingKnee?: number;
   /** Strengthen display stabilization for single-sample stochastic noise. */
   stabilizeNoise?: boolean;
   /** Gain of the variance gate between the two history paths. */
@@ -111,7 +125,14 @@ export type NeuralDenoiseModel = {
     pointwise3: NeuralDenoiseLayer;
     head: NeuralDenoiseLayer;
   };
-};
+} & (
+  | { compact?: false }
+  | {
+      compact: true;
+      compactMix: [settled: number, movingOrShort: number];
+      movingKnee: number;
+    }
+);
 export declare const neuralDenoiseModels: {
   quality: NeuralDenoiseModel;
   performance: NeuralDenoiseModel;

package/dist/types/addons/neuralDenoiseWeights.d.ts

@@ -9,8 +9,22 @@ export type NeuralDenoiseLayer = {
  * Trained on this renderer's stochastic frames.
  */
 export type NeuralDenoiseModel = {
-  /** Use fixed local filtering without learned multiscale passes. */
+  /**
+   * Use fixed local filtering without learned multiscale passes.
+   * Requires `compactMix` and `movingKnee` when true.
+   */
   compact?: boolean;
+  /**
+   * Required with `compact`: shares of the 3x3 mean, each in [0, 1], for
+   * settled denoised history and for camera motion or short history.
+   * The transition uses `movingKnee` and `reach`.
+   */
+  compactMix?: [settled: number, movingOrShort: number];
+  /**
+   * Required with `compact`: positive camera-induced screen motion, in
+   * pixels per frame, at which the motion response is 0.5.
+   */
+  movingKnee?: number;
   /** Strengthen display stabilization for single-sample stochastic noise. */
   stabilizeNoise?: boolean;
   /** Gain of the variance gate between the two history paths. */
@@ -111,7 +125,14 @@ export type NeuralDenoiseModel = {
     pointwise3: NeuralDenoiseLayer;
     head: NeuralDenoiseLayer;
   };
-};
+} & (
+  | { compact?: false }
+  | {
+      compact: true;
+      compactMix: [settled: number, movingOrShort: number];
+      movingKnee: number;
+    }
+);
 export declare const neuralDenoiseModels: {
   quality: NeuralDenoiseModel;
   performance: NeuralDenoiseModel;

package/dist/types/index.d.cts

@@ -2,11 +2,10 @@ export {
   GaussianSplatRenderer,
   type GaussianSplatRendererOptions,
 } from "./rendering/GaussianSplatRenderer.cjs";
-export { TAAPass } from "./addons/TAAPass.cjs";
-export { TAANode } from "./addons/TAANode.cjs";
 export type { NeuralDenoiseMode } from "./addons/NeuralDenoiseNode.cjs";
 export { NeuralDenoiseNode } from "./addons/NeuralDenoiseNode.cjs";
 export { NeuralDenoisePass } from "./addons/NeuralDenoisePass.cjs";
+export { NeuralDenoiseXR } from "./addons/NeuralDenoiseXR.cjs";
 export {
   SplatCapture,
   type SplatCaptureOptions,

package/dist/types/index.d.ts

@@ -2,11 +2,10 @@ export {
   GaussianSplatRenderer,
   type GaussianSplatRendererOptions,
 } from "./rendering/GaussianSplatRenderer.js";
-export { TAAPass } from "./addons/TAAPass.js";
-export { TAANode } from "./addons/TAANode.js";
 export type { NeuralDenoiseMode } from "./addons/NeuralDenoiseNode.js";
 export { NeuralDenoiseNode } from "./addons/NeuralDenoiseNode.js";
 export { NeuralDenoisePass } from "./addons/NeuralDenoisePass.js";
+export { NeuralDenoiseXR } from "./addons/NeuralDenoiseXR.js";
 export {
   SplatCapture,
   type SplatCaptureOptions,

package/dist/types/rendering/GaussianSplatRenderer.d.cts

@@ -200,6 +200,7 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<
   onDirty?: () => void;
   dirty: boolean;
   private readonly backend;
+  private readonly geometries;
   private readonly materialState;
   private orderingBuffer;
   private orderingReady;
@@ -333,7 +334,6 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<
    * the update boundary too, keeping mode changes outside an active draw.
    */
   private syncStochasticFrame;
-  private selectMaterial;
   private applyMaterialState;
   private reportedRenderError;
   private runAutomaticUpdate;

package/dist/types/rendering/GaussianSplatRenderer.d.ts

@@ -200,6 +200,7 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<
   onDirty?: () => void;
   dirty: boolean;
   private readonly backend;
+  private readonly geometries;
   private readonly materialState;
   private orderingBuffer;
   private orderingReady;
@@ -333,7 +334,6 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<
    * the update boundary too, keeping mode changes outside an active draw.
    */
   private syncStochasticFrame;
-  private selectMaterial;
   private applyMaterialState;
   private reportedRenderError;
   private runAutomaticUpdate;

package/dist/types/rendering/SplatGeometry.d.cts

@@ -1,7 +1,7 @@
 import * as THREE from "three";
 export declare const SPLATS_PER_INSTANCE = 128;
-/** Repeated quads; position.z identifies the Splat within each instance. */
+/** Repeated triangles or quads; position.z identifies the Splat in each instance. */
 export declare class SplatGeometry extends THREE.InstancedBufferGeometry {
-  constructor();
+  constructor(triangle?: boolean);
   setSplatCount(count: number): void;
 }

package/dist/types/rendering/SplatGeometry.d.ts

@@ -1,7 +1,7 @@
 import * as THREE from "three";
 export declare const SPLATS_PER_INSTANCE = 128;
-/** Repeated quads; position.z identifies the Splat within each instance. */
+/** Repeated triangles or quads; position.z identifies the Splat in each instance. */
 export declare class SplatGeometry extends THREE.InstancedBufferGeometry {
-  constructor();
+  constructor(triangle?: boolean);
   setSplatCount(count: number): void;
 }

package/docs/GaussianSplatRenderer.md

@@ -58,7 +58,7 @@ On native WebGPU, Splats are sorted before every draw. On WebGL, sorting finishe
 
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
-| `stochastic` | `boolean` | `false` | Use stochastic rendering; smooth its noise with temporal anti-aliasing |
+| `stochastic` | `boolean` | `false` | Use stochastic rendering; smooth its noise with neural denoising |
 | `stochasticSort` | `boolean` | `true` | Sort Splats from front to back in stochastic rendering; `false` skips sorting |
 | `autoAdvanceStochasticSample` | `boolean` | `true` | Change the noise pattern on every render, including in WebXR |
 
@@ -100,7 +100,7 @@ Model colors are converted for you. Control the final image with your Three.js r
 
 Set `encodeLinear` to choose the conversion yourself. For example, to blend Splats in sRGB next to a linear scene, render them into their own target with `encodeLinear: false`, then unpremultiply that layer, convert it to linear, and premultiply it again before compositing.
 
-For temporal anti-aliasing and effects such as Bloom, see [TAAPass and TAANode](TAAPass.md). To render offscreen, read pixels back, or build cube and environment maps, use [SplatCapture](SplatCapture.md).
+For neural denoising and effects such as Bloom, see [Neural denoising](NeuralDenoiseNode.md). To render offscreen, read pixels back, or build cube and environment maps, use [SplatCapture](SplatCapture.md).
 
 ## On-demand rendering
 

package/docs/NeuralDenoiseNode.md

@@ -1,18 +1,10 @@
-# NeuralDenoiseNode and NeuralDenoisePass (Experimental)
+# Neural denoising (Experimental)
 
 [Back to documentation](../README.md#documentation)
 
-The experimental neural denoiser smooths [stochastic rendering](StochasticRendering.md). Use `NeuralDenoiseNode` with `WebGPURenderer`, including its WebGL2 fallback, or `NeuralDenoisePass` with `WebGLRenderer`. The trained models are included; no extra downloads are needed.
+The experimental neural denoiser smooths [stochastic rendering](StochasticRendering.md). Use `NeuralDenoiseNode` with `WebGPURenderer`, including its WebGL2 fallback, or `NeuralDenoisePass` with `WebGLRenderer`. For immersive rendering, use [NeuralDenoiseXR](#webxr) with either renderer. The trained models are included; no extra downloads are needed.
 
-## Choose between TAA and neural denoising
-
-| | `TAANode` / `TAAPass` | `NeuralDenoiseNode` / `NeuralDenoisePass` |
-| --- | --- | --- |
-| Moving objects | May leave a faint trail | Helps reduce trails; moving detail can still look soft or grainy |
-| Camera movement | Some grain returns | Smooths noise during movement; fast turns can look softer |
-| Cost | Lower | Depends on mode; Quality uses more GPU time and memory |
-
-With neural denoising, newly exposed backgrounds need time to settle. Results vary by scene and motion.
+Neural denoising smooths noise during movement and helps reduce trails behind moving objects. Moving detail can still look soft or grainy, and newly exposed backgrounds need time to settle. Results vary by scene and motion.
 
 ## Choose a mode
 
@@ -48,7 +40,7 @@ With MSAA off, stabilization is stronger to reduce flicker, which can add some t
 ## Before you start
 
 - **WebGL2 requirements.** Both WebGL2 paths require `EXT_color_buffer_float`. MSAA also requires `OES_sample_variables`; check `renderer.getContext().getExtension("OES_sample_variables")` before enabling MSAA. If it is unavailable, leave MSAA disabled. Unsupported configurations throw an error.
-- **One camera.** Use a `PerspectiveCamera` or `OrthographicCamera`. WebXR is not supported.
+- **Camera.** Use a `PerspectiveCamera` or `OrthographicCamera` for the node/pass. For WebXR, use `NeuralDenoiseXR` with your application's `PerspectiveCamera` as shown below.
 - **Stencil masks.** Create the Three.js renderer with `stencil: true` to use them.
 - **Reset after a jump.** Call `denoise.reset()` after a camera cut or scene replacement. Resizing resets automatically; normal object movement needs no reset.
 - **On-demand rendering.** Keep rendering after each change so the image can settle.
@@ -88,7 +80,7 @@ const pipeline = new RenderPipeline(renderer, color.add(bloom(color, 0.6, 0.4, 0
 
 ## WebGLRenderer: NeuralDenoisePass
 
-Use the pass in place of `RenderPass` or `TAAPass`:
+Use the pass in place of `RenderPass`:
 
 ```js
 import { NeuralDenoisePass } from "gaussian-splat-lite";
@@ -114,6 +106,33 @@ renderer.setAnimationLoop(() => {
 // On cleanup: stop the animation loop, then dispose the composer and each pass.
 ```
 
+## WebXR
+
+Use `NeuralDenoiseXR` during XR frames. It supports `WebGLRenderer` and initialized `WebGPURenderer`, including its WebGL2 fallback. Each eye uses its own image history and resolution; both modes and optional MSAA are available.
+
+```js
+import { NeuralDenoiseXR } from "gaussian-splat-lite";
+
+renderer.xr.enabled = true;
+splatRenderer.stochastic = true;
+const xrDenoise = new NeuralDenoiseXR(renderer, scene, camera, "performance");
+
+renderer.setAnimationLoop(() => {
+  // Update animation here. Start the XR session using your normal XR button.
+  if (renderer.xr.isPresenting) xrDenoise.render();
+  else renderer.render(scene, camera); // Or your desktop denoising pipeline.
+});
+
+// After a teleport or scene replacement: xrDenoise.reset().
+// On cleanup: xrDenoise.dispose().
+```
+
+Call `render()` directly during an active XR animation frame. It presents the final image, including tone mapping and output color conversion; do not put it in an `EffectComposer` or `RenderPipeline`. Those desktop pipelines do not automatically become stereo pipelines. When using a desktop denoiser too, reset its history when leaving XR.
+
+The constructor takes `(renderer, scene, camera, mode = "quality", msaa = false)`. `scene`, `camera`, and `stabilize` can be changed; call `reset()` after replacing the scene or camera. If `renderer.xr.cameraAutoUpdate` is `false`, update the XR camera yourself before rendering. Eye resizing resets history automatically, and ending the session releases the eye resources.
+
+Stereo rendering increases GPU and memory use. Start with `"performance"` and MSAA off, and check image quality and frame timing on the target headset. Native WebGPU also requires the browser's [WebXR WebGPU binding](https://immersive-web.github.io/webxr-webgpu-binding/) and a session requested with the `"webgpu"` feature. The XR path presents color only; it does not provide scene depth to the XR compositor or a stereo postprocessing chain.
+
 ## Color
 
 `RenderPipeline`, or the composer's `OutputPass`, applies tone mapping and the output color space at the end.

package/docs/StochasticRendering.md

@@ -2,9 +2,9 @@
 
 [Back to documentation](../README.md#documentation)
 
-Stochastic rendering is an optional way for `GaussianSplatRenderer` to draw transparency. It produces visible noise, so pair it with temporal anti-aliasing (TAA) or the experimental neural denoiser to get a smooth image. Sorted alpha blending remains the default.
+Stochastic rendering is an optional way for `GaussianSplatRenderer` to draw transparency. It produces visible noise, so pair it with the experimental neural denoiser to get a smooth image. Sorted alpha blending remains the default.
 
-Stochastic rendering works on WebGPU, WebGL2, and `WebGPURenderer`'s WebGL2 fallback, including WebXR. The smoothing options below do not support WebXR.
+Stochastic rendering works on WebGPU, WebGL2, and `WebGPURenderer`'s WebGL2 fallback, including WebXR. For immersive rendering, use [NeuralDenoiseXR](NeuralDenoiseNode.md#webxr).
 
 ## Turn it on
 
@@ -24,21 +24,21 @@ Both can be changed at any time. While stochastic rendering is active, Splats ar
 
 ## Smooth the noise
 
-Use [`TAANode`](TAAPass.md#taanode-webgpurenderer) with `WebGPURenderer`, or [`TAAPass`](TAAPass.md#taapass-webglrenderer) with `WebGLRenderer`. The [experimental neural denoiser](NeuralDenoiseNode.md) is an alternative for scenes with moving objects on all three backends. The library does not turn any of them on for you. The examples assume an existing `renderer`, `scene`, `camera`, and `splatRenderer`, with one camera outside WebXR.
+Use [`NeuralDenoiseNode`](NeuralDenoiseNode.md#webgpurenderer-neuraldenoisenode) with `WebGPURenderer`, or [`NeuralDenoisePass`](NeuralDenoiseNode.md#webglrenderer-neuraldenoisepass) with `WebGLRenderer`. The library does not turn denoising on for you. The examples assume an existing `renderer`, `scene`, `camera`, and `splatRenderer`, with one camera outside WebXR.
 
-### WebGPURenderer: TAANode
+### WebGPURenderer: NeuralDenoiseNode
 
 Use this on both WebGPU and the WebGL2 fallback, after `await renderer.init()`:
 
 ```js
-import { TAANode } from "gaussian-splat-lite";
+import { NeuralDenoiseNode } from "gaussian-splat-lite";
 import { RenderPipeline } from "three/webgpu";
 
 splatRenderer.stochastic = true;
 
-const taa = new TAANode(scene, camera);
-// Chain Bloom or other effects from taa here.
-const pipeline = new RenderPipeline(renderer, taa);
+const denoise = new NeuralDenoiseNode(scene, camera);
+// Chain Bloom or other effects from denoise here.
+const pipeline = new RenderPipeline(renderer, denoise);
 
 renderer.setAnimationLoop(() => {
   // Update controls / animation here.
@@ -46,31 +46,20 @@ renderer.setAnimationLoop(() => {
 });
 ```
 
-### WebGPURenderer: NeuralDenoiseNode
-
-To help reduce trails behind moving objects, replace `TAANode` in the setup above with `NeuralDenoiseNode`:
-
-```js
-import { NeuralDenoiseNode } from "gaussian-splat-lite";
-
-const denoise = new NeuralDenoiseNode(scene, camera);
-const pipeline = new RenderPipeline(renderer, denoise);
-```
-
-It also supports the WebGL2 fallback. See [Neural denoising](NeuralDenoiseNode.md) for modes, MSAA and WebGL2 requirements.
+See [Neural denoising](NeuralDenoiseNode.md) for modes, MSAA and WebGL2 requirements.
 
-### WebGLRenderer: TAAPass
+### WebGLRenderer: NeuralDenoisePass
 
 ```js
-import { TAAPass } from "gaussian-splat-lite";
+import { NeuralDenoisePass } from "gaussian-splat-lite";
 import { EffectComposer } from "three/addons/postprocessing/EffectComposer.js";
 import { OutputPass } from "three/addons/postprocessing/OutputPass.js";
 
 splatRenderer.stochastic = true;
 
-const taa = new TAAPass(scene, camera);
+const denoise = new NeuralDenoisePass(scene, camera);
 const composer = new EffectComposer(renderer);
-composer.addPass(taa);
+composer.addPass(denoise);
 // Insert Bloom or other effects here.
 composer.addPass(new OutputPass());
 
@@ -80,31 +69,20 @@ renderer.setAnimationLoop(() => {
 });
 ```
 
-`TAAPass` takes the place of `RenderPass`. On resize, call `composer.setSize(width, height)` along with the renderer.
-
-### WebGLRenderer: NeuralDenoisePass
-
-Replace `TAAPass` in the composer setup above with `NeuralDenoisePass`, keeping `OutputPass` after it:
-
-```js
-import { NeuralDenoisePass } from "gaussian-splat-lite";
-
-const denoise = new NeuralDenoisePass(scene, camera);
-composer.addPass(denoise);
-```
+`NeuralDenoisePass` takes the place of `RenderPass`. On resize, call `composer.setSize(width, height)` along with the renderer.
 
 It has the same options and requirements as `NeuralDenoiseNode` on WebGL2.
 
-### With any of these
+### History and on-demand rendering
 
-- Call `reset()` after a camera cut or a scene replacement. With TAA, also call it after an abrupt change to an object: TAA follows camera movement, not moving objects.
+- Call `reset()` after a camera cut or a scene replacement.
 - With on-demand rendering, keep rendering for several frames after the camera, a model, or streamed content changes, and after the Splat renderer's `onDirty` callback, so the noise can settle.
 
-See [TAAPass and TAANode](TAAPass.md) and [Neural denoising](NeuralDenoiseNode.md) for effects, depth, color, and cleanup.
+See [Neural denoising](NeuralDenoiseNode.md) for effects, depth, color, and cleanup.
 
 ## Control the noise pattern
 
-The noise pattern changes on every render so TAA or neural denoising can smooth it over time. To keep it fixed, or to control it from your own render loop:
+The noise pattern changes on every render so neural denoising can smooth it over time. To keep it fixed, or to control it from your own render loop:
 
 ```js
 splatRenderer.autoAdvanceStochasticSample = false;
@@ -119,11 +97,11 @@ When you advance it yourself, increase it by one for each render of the scene. T
 splatRenderer.stochastic = false;
 ```
 
-The switch, in either direction, takes effect on a later frame rather than immediately. `stochasticActive` tells you which mode is being drawn; keep your TAA or neural denoiser running until it is `false`. With `autoUpdate = false`, update before drawing:
+The switch, in either direction, takes effect on a later frame rather than immediately. `stochasticActive` tells you which mode is being drawn; keep your neural denoiser running until it is `false`. With `autoUpdate = false`, update before drawing:
 
 ```js
 await splatRenderer.update({ scene, camera });
 renderer.render(scene, camera);
 ```
 
-If you keep TAA or neural denoising running with sorted rendering, set `splatRenderer.depthWrite = true` so it can use the Splats' depth.
+If you keep neural denoising running with sorted rendering, set `splatRenderer.depthWrite = true` so it can use the Splats' depth.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaussian-splat-lite",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Three.js Gaussian Splatting renderer with WebGPU/WebGL2, GPU sorting, streaming LOD, and high-precision GIS/ECEF support. Supports PLY, SPZ, SOG and RAD.",
   "author": "William Liu <lyz15972107087@gmail.com>",
   "type": "module",

package/dist/types/addons/TAANode.d.cts

@@ -1,49 +0,0 @@
-import type {
-  DepthTexture,
-  Matrix4,
-  OrthographicCamera,
-  PerspectiveCamera,
-  Scene,
-} from "three";
-import { Node, type NodeBuilder, type NodeFrame } from "three/webgpu";
-/** Camera/depth TAA for WebGPURenderer, including its WebGL2 fallback. */
-export declare class TAANode extends Node<"vec4"> {
-  scene: Scene;
-  camera: PerspectiveCamera | OrthographicCamera;
-  readonly msaa: boolean;
-  private readonly coverage;
-  static get type(): string;
-  depthThreshold: number;
-  edgeDepthDiff: number;
-  maxMotionLength: number;
-  useSubpixelCorrection: boolean;
-  private readonly source;
-  private readonly history;
-  private readonly historyColor;
-  private readonly historyDepth;
-  private readonly textureNode;
-  private readonly material;
-  private readonly quad;
-  private readonly state;
-  private readonly zeroToOne;
-  private readonly drawingSize;
-  private workingColorSpace;
-  private readonly pipelineStates;
-  private pipelineRendering;
-  private capturePending;
-  /** @param msaa Enable 4× MSAA (default false). Fixed for the node's lifetime. */
-  constructor(
-    scene: Scene,
-    camera: PerspectiveCamera | OrthographicCamera,
-    msaa?: boolean,
-  );
-  private makeTarget;
-  get depthTexture(): DepthTexture;
-  get projectionMatrix(): Matrix4;
-  getTextureNode(): import("three/webgpu").TextureNode;
-  setSize(width: number, height: number): void;
-  reset(): void;
-  updateBefore(frame: NodeFrame): undefined;
-  setup(builder: NodeBuilder): import("three/webgpu").TextureNode;
-  dispose(): void;
-}

package/dist/types/addons/TAANode.d.ts

@@ -1,49 +0,0 @@
-import type {
-  DepthTexture,
-  Matrix4,
-  OrthographicCamera,
-  PerspectiveCamera,
-  Scene,
-} from "three";
-import { Node, type NodeBuilder, type NodeFrame } from "three/webgpu";
-/** Camera/depth TAA for WebGPURenderer, including its WebGL2 fallback. */
-export declare class TAANode extends Node<"vec4"> {
-  scene: Scene;
-  camera: PerspectiveCamera | OrthographicCamera;
-  readonly msaa: boolean;
-  private readonly coverage;
-  static get type(): string;
-  depthThreshold: number;
-  edgeDepthDiff: number;
-  maxMotionLength: number;
-  useSubpixelCorrection: boolean;
-  private readonly source;
-  private readonly history;
-  private readonly historyColor;
-  private readonly historyDepth;
-  private readonly textureNode;
-  private readonly material;
-  private readonly quad;
-  private readonly state;
-  private readonly zeroToOne;
-  private readonly drawingSize;
-  private workingColorSpace;
-  private readonly pipelineStates;
-  private pipelineRendering;
-  private capturePending;
-  /** @param msaa Enable 4× MSAA (default false). Fixed for the node's lifetime. */
-  constructor(
-    scene: Scene,
-    camera: PerspectiveCamera | OrthographicCamera,
-    msaa?: boolean,
-  );
-  private makeTarget;
-  get depthTexture(): DepthTexture;
-  get projectionMatrix(): Matrix4;
-  getTextureNode(): import("three/webgpu").TextureNode;
-  setSize(width: number, height: number): void;
-  reset(): void;
-  updateBefore(frame: NodeFrame): undefined;
-  setup(builder: NodeBuilder): import("three/webgpu").TextureNode;
-  dispose(): void;
-}