gaussian-splat-lite 1.2.2 → 1.3.1

package/docs/NeuralDenoiseNode.md

@@ -0,0 +1,148 @@
+# NeuralDenoiseNode and NeuralDenoisePass (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.
+
+## 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.
+
+## Choose a mode
+
+The third constructor argument, `mode`, selects the balance of image quality and cost. Start with the default, then compare detail, noise and flicker in your scenes.
+
+| Mode | What you get |
+| --- | --- |
+| `"quality"` (default) | Prioritizes noise suppression and detail retention, with higher GPU and memory use |
+| `"performance"` | Prioritizes lower GPU and memory use |
+
+```js
+const denoise = new NeuralDenoiseNode(scene, camera, "performance");
+// NeuralDenoisePass accepts the same arguments.
+```
+
+To change modes, dispose the node or pass and create another.
+
+For existing code, replace `"profile2"` with `"quality"`, `profile` with `mode`, and `NeuralDenoiseProfile` with `NeuralDenoiseMode`. `"profile1"` is no longer supported.
+
+## MSAA
+
+The fourth constructor argument, `msaa`, enables or disables 4× MSAA in either mode:
+
+| MSAA | What you get |
+| --- | --- |
+| `false` (default) | Lower GPU and memory use |
+| `true` | Less noise during motion, with higher GPU and memory use |
+
+For example, `new NeuralDenoiseNode(scene, camera, "performance", true)` enables MSAA. `NeuralDenoisePass` accepts the same arguments. To change MSAA, dispose the node or pass and create another.
+
+With MSAA off, stabilization is stronger to reduce flicker, which can add some trailing or softness during motion.
+
+## 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.
+- **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.
+
+## WebGPURenderer: NeuralDenoiseNode
+
+After `await renderer.init()`, with an existing `renderer`, `scene`, `camera`, and `splatRenderer`:
+
+```js
+import { NeuralDenoiseNode } from "gaussian-splat-lite";
+import { RenderPipeline } from "three/webgpu";
+
+splatRenderer.stochastic = true;
+
+const denoise = new NeuralDenoiseNode(scene, camera);
+const pipeline = new RenderPipeline(renderer, denoise);
+
+renderer.setAnimationLoop(() => {
+  // Update controls / animation here.
+  pipeline.render();
+});
+
+// On a camera cut or scene replacement: denoise.reset().
+// On cleanup: stop the animation loop, then dispose the pipeline and denoise.
+```
+
+The node renders the scene and follows the renderer's size automatically.
+
+Chain effects from the node or from `denoise.getTextureNode()`. For Bloom, create the pipeline like this instead:
+
+```js
+import { bloom } from "three/addons/tsl/display/BloomNode.js";
+
+const color = denoise.getTextureNode();
+const pipeline = new RenderPipeline(renderer, color.add(bloom(color, 0.6, 0.4, 0.8)));
+```
+
+## WebGLRenderer: NeuralDenoisePass
+
+Use the pass in place of `RenderPass` or `TAAPass`:
+
+```js
+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 denoise = new NeuralDenoisePass(scene, camera);
+const composer = new EffectComposer(renderer);
+composer.addPass(denoise);
+// Insert Bloom or other effects here.
+composer.addPass(new OutputPass());
+
+renderer.setAnimationLoop(() => {
+  // Update controls / animation here.
+  composer.render();
+});
+
+// On resize: update the renderer size and camera projection,
+// then call composer.setSize(width, height) in CSS pixels.
+// On a camera cut or scene replacement: denoise.reset().
+// On cleanup: stop the animation loop, then dispose the composer and each pass.
+```
+
+## Color
+
+`RenderPipeline`, or the composer's `OutputPass`, applies tone mapping and the output color space at the end.
+
+With `NeuralDenoiseNode` in a linear working color space, enabling MSAA can make partly transparent Splats look brighter. This does not occur with `NeuralDenoisePass` or with `NeuralDenoiseNode` in an sRGB working color space. MSAA results can also differ at edges between WebGPU and WebGL2.
+
+## Properties
+
+| Property | Default | Description |
+| --- | --- | --- |
+| `scene` | Constructor scene | Scene to render; call `reset()` when replacing it |
+| `camera` | Constructor camera | Camera to render with; call `reset()` when replacing it |
+| `mode` | `"quality"` | Read-only. `"performance"` or `"quality"` |
+| `msaa` | `false` | Read-only. Whether 4× MSAA is enabled |
+| `depthTexture` | Read-only | Scene depth of the current frame |
+| `projectionMatrix` | Read-only | Projection that matches `depthTexture` |
+| `stabilize` | `true` | Reduces flicker in both modes; disabling it can make the image less steady |
+
+Read `depthTexture` when setting up a depth-based effect; it updates each frame after that. Use the matching `projectionMatrix` for depth conversion, rather than `camera.projectionMatrix`. The depth is not smoothed.
+
+## Methods
+
+| Method | Description |
+| --- | --- |
+| `reset()` | Discard earlier frames and start smoothing again |
+| `dispose()` | Release the resources it holds. The scene is not disposed |
+| `setSize(width, height)` | Resize in physical pixels. Called for you; a size change resets |
+| `getTextureNode()` | Node only: the smoothed image, for chaining effects |
+
+## Background
+
+Based on Hu et al., [Ultra-fast Neural Inference for Stochastic Gaussian Splatting Denoising](https://arxiv.org/abs/2609.25604), adapted for this library.

package/docs/RadStreamScheduler.md

@@ -10,6 +10,9 @@ import { RadStreamScheduler } from "gaussian-splat-lite";
 const streaming = new RadStreamScheduler({
   url: "/models/scene.rad",
   splatBudget: 3_000_000,
+  splatBudgetTolerance: 0.1, // Allow up to 10% extra Splats; 0 forbids overshoot.
+  maxResidentCpuBytes: 2 * 1024 * 1024 * 1024, // 2 GiB
+  maxResidentGpuBytes: 1024 * 1024 * 1024, // 1 GiB
 });
 scene.add(streaming.group);
 streaming.setCamera(camera);
@@ -72,16 +75,21 @@ renderer.setAnimationLoop(() => {
 | `url` / `file` / `fileBytes` | Exactly one required | URL, `Blob`/`File`, or complete `Uint8Array`/`ArrayBuffer` |
 | `resolveFile` | Relative URLs | Supply the `.radc` pages of a split scene yourself: `(filename, signal) => URL \| Blob \| Uint8Array \| ArrayBuffer`, directly or as a promise |
 | `group` | New `THREE.Group` | Group that holds the scene |
-| `splatBudget` | `3_000_000` | Maximum number of Splats shown at once. Higher values show more detail and use more memory |
+| `splatBudget` | `3_000_000` | Target number of Splats. Higher values show more detail and use more memory |
+| `splatBudgetTolerance` | `0.1` | Allowed fractional overshoot of `splatBudget`. `0.1` allows up to 10% extra Splats; `0` keeps each new selection within `splatBudget`. Must be finite and nonnegative |
+| `maxResidentCpuBytes` | 2 GiB | CPU memory budget for cached data, in bytes. Set a positive integer when creating the scheduler |
+| `maxResidentGpuBytes` | 1 GiB | GPU memory budget for cached data, in bytes. Set a positive integer when creating the scheduler |
 | `fadeDurationMs` | `200` | Duration of the fade when the scene first appears and when detail changes; `0` switches instantly |
-| `cooldownMs` | `2000` | How long detail that is no longer shown stays in memory, ready for reuse; `0` releases it at once |
-| `maxConcurrentLoads` | `4` | Maximum number of loads in progress at the same time |
+| `cooldownMs` | `2000` | How long unused detail stays ready for reuse; it can be released sooner when either memory budget is reached. `0` releases it at once |
+| `maxConcurrentLoads` | `4` | Maximum number of simultaneous loads, regardless of page size. |
 | `manager` | `THREE.DefaultLoadingManager` | Three.js loading manager, including its URL modifiers |
 | `requestHeader` / `withCredentials` | `{}` / `false` | Request settings. Sensitive settings are not sent to other origins |
 | `onChange` | — | Called when the scene needs a redraw |
 | `onError` | Logs to the console | Called when loading fails: `(error, url)` |
 
-Detail that is already on screen stays there while its replacement loads. During a fade, old and new detail overlap, so the scene can briefly exceed `splatBudget`; use `fadeDurationMs: 0` to prevent this. The budget limits what is shown, not total memory: detail kept for reuse takes memory too.
+Detail already on screen stays visible while its replacement loads, if both memory budgets allow. At the limit, the scene may temporarily show less detail. During a fade, old and new detail overlap, so the visible count can briefly exceed the selection limit. Use both `splatBudgetTolerance: 0` and `fadeDurationMs: 0` to keep new selections and their transitions within `splatBudget`.
+
+Unused detail is released after `cooldownMs`, including while hidden, and loads again when needed.
 
 ## Properties and methods
 
@@ -89,6 +97,7 @@ Detail that is already on screen stays there while its replacement loads. During
 | --- | --- |
 | `group` | Group that holds the scene |
 | `splatBudget` | Change it at any time to adjust detail, even while the camera is still. Must be a positive integer |
+| `splatBudgetTolerance` | Change the allowed overshoot at any time without reloading. `0` forbids overshoot |
 | `initialized` | Resolves when the scene is set up; rejects for invalid or unsupported files |
 | `firstRenderable` | Resolves when the first data is on screen, or the scene is empty; rejects if the first data cannot be loaded. Keep calling `update()` while you wait |
 | `setCamera(camera)` / `deleteCamera(camera)` | Add or remove a camera that chooses detail. `hasCamera(camera)` and `cameras` report the registered ones |
@@ -97,7 +106,7 @@ Detail that is already on screen stays there while its replacement loads. During
 | `update()` | Advance detail selection, loading, and fades. Call it before every render; it throws if no camera is registered |
 | `getBoundingBox()` | Approximate box around the scene, in the group's coordinates; empty until the first data loads |
 | `getGlobalIndex(mesh, renderedIndex)` | Convert a picking hit into a node index that stays the same for the whole RAD file |
-| `stats` | Numbers for monitoring, such as `visibleSplats`, `loadingChunks`, `downloadedBytes`, and `residentBytes`. Memory figures are estimates, not total browser memory |
+| `stats` | Visible Splats, loading progress, and estimated CPU/GPU cache sizes (`residentCpuBytes` / `residentGpuBytes`) |
 | `dispose()` | Stop loading and release the scene. Pending `initialized` and `firstRenderable` promises reject with `AbortError` |
 
 ### On-demand rendering

package/docs/SogStreamScheduler.md

@@ -48,7 +48,10 @@ In WebXR, register `renderer.xr.getCamera()` in place of your camera, as shown f
 | --- | --- | --- |
 | `url` | Required | URL of the scene's `lod-meta.json` |
 | `group` | New `THREE.Group` | Group that holds the scene |
-| `splatBudget` | `3_000_000` | Target number of Splats shown at once, including the environment. Higher values show more detail and use more memory |
+| `splatBudget` | `3_000_000` | Splat budget, including the environment. Higher values allow more detail and use more memory |
+| `splatBudgetMode` | `"target"` | `"target"` adjusts the distance bands to fill the budget. `"limit"` uses the configured distance bands and only reduces detail when they exceed the budget |
+| `lodBaseDistance` | `100` | Base LOD distance in world units for `"limit"` mode, compensated for the camera's field of view. Higher values retain finer detail farther away. Must be finite and positive |
+| `lodMultiplier` | `2` | Distance multiplier between successive LOD levels in both modes. Must be finite and at least `1` |
 | `fadeDurationMs` | `200` | Duration of the fade when the scene first appears and when detail changes; `0` switches instantly |
 | `cooldownMs` | `2000` | How long detail that is no longer shown stays in memory, ready for reuse; `0` releases it at once |
 | `maxConcurrentLoads` | `4` | Maximum number of loads in progress at the same time |
@@ -58,22 +61,21 @@ In WebXR, register `renderer.xr.getCamera()` in place of your camera, as shown f
 | `onError` | Logs to the console | Called when loading fails: `(error, url)` |
 | `loadChunk` | Built-in loader | Load the scene's files yourself: `(url, signal) => Promise<Splats>` |
 
-The budget is a target, not a hard limit: the available detail levels, fades, and the environment can take the scene above it. It limits what is shown, not total memory: detail kept for reuse takes memory too.
-
-Some parts of a scene exist only at finer detail levels. They can be empty from far away and fade in as the camera approaches.
-
 ## Properties and methods
 
 | API | Description |
 | --- | --- |
 | `group` | Group that holds the scene |
 | `splatBudget` | Change it at any time to adjust detail. Must be a positive integer; includes the environment |
+| `splatBudgetMode` | Switch between `"target"` and `"limit"` without reloading |
+| `lodBaseDistance` | Change the base LOD distance in `"limit"` mode without reloading |
+| `lodMultiplier` | Change the distance spacing between LOD levels in both modes without reloading |
 | `initialized` | Resolves when the index is loaded; rejects for invalid input |
 | `firstRenderable` | Resolves when the first data is on screen, or the scene is empty; rejects if the first data cannot be loaded. Keep calling `update()` while you wait |
 | `setCamera(camera)` / `deleteCamera(camera)` | Add or remove a camera that chooses detail. `hasCamera(camera)` and `cameras` report the registered ones |
 | `update()` | Advance detail selection, loading, and fades. Call it before every render; it throws if no camera is registered |
 | `getBoundingBox()` | Box around the scene, in the group's coordinates; available once `initialized` resolves |
-| `stats` | Numbers for monitoring, such as `visibleSplats`, `visibleRegions`, `loadingChunks`, `downloadedBytes`, and `residentBytes`. Memory figures are estimates, not total browser memory |
+| `stats` | Visible Splats, loading progress, and estimated CPU/GPU cache sizes (`residentCpuBytes` / `residentGpuBytes`) |
 | `dispose()` | Stop loading and release the scene. Pending `initialized` and `firstRenderable` promises reject with `AbortError` |
 
 ### On-demand rendering

package/docs/SplatMesh.md

@@ -46,7 +46,7 @@ For large streamed scenes, use [RadStreamScheduler](RadStreamScheduler.md) or [S
 | `onFrame` | `({ mesh, time, deltaTime }) => void` | `undefined` | Called before each update of the model; use it for animation |
 | `editable` | `boolean` | `true` | Allow [SDF edits](SplatEdit.md) to affect this model |
 | `raycastable` | `boolean` | `true` | Include this model in Three.js raycasting |
-| `minRaycastOpacity` | `number` | `0.15` | Ignore more transparent areas when picking; higher values narrow the area that can be hit |
+| `minRaycastOpacity` | `number` | `0.1` | Ignore more transparent areas when picking; higher values narrow the area that can be hit |
 
 Choose at most one of `url`, `file`, `fileBytes`, or `splats`; combining them throws.
 

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) 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 temporal anti-aliasing (TAA) or the experimental neural denoiser to get a smooth image. Sorted alpha blending remains the default.
 
-It works on WebGPU, WebGL2, and `WebGPURenderer`'s WebGL2 fallback, including WebXR.
+Stochastic rendering works on WebGPU, WebGL2, and `WebGPURenderer`'s WebGL2 fallback, including WebXR. The smoothing options below do not support WebXR.
 
 ## Turn it on
 
@@ -24,7 +24,7 @@ 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 library does not turn TAA on for you. The examples assume an existing `renderer`, `scene`, `camera`, and `splatRenderer`, with one camera outside WebXR.
+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.
 
 ### WebGPURenderer: TAANode
 
@@ -46,6 +46,19 @@ 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.
+
 ### WebGLRenderer: TAAPass
 
 ```js
@@ -69,16 +82,29 @@ renderer.setAnimationLoop(() => {
 
 `TAAPass` takes the place of `RenderPass`. On resize, call `composer.setSize(width, height)` along with the renderer.
 
-### With either setup
+### 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);
+```
+
+It has the same options and requirements as `NeuralDenoiseNode` on WebGL2.
+
+### With any of these
 
-- Call `taa.reset()` after a camera cut, a scene replacement, or an abrupt change to an object. TAA follows camera movement, not moving objects.
-- 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. The viewer renders 32.
+- 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.
+- 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) for effects, depth, color, and cleanup. The repository's `examples/viewer/viewerTAA.js` shows both setups.
+See [TAAPass and TAANode](TAAPass.md) and [Neural denoising](NeuralDenoiseNode.md) for effects, depth, color, and cleanup.
 
 ## Control the noise pattern
 
-The noise pattern changes on every render, which is what lets TAA smooth it over time. To keep it fixed, or to drive it from your own TAA:
+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:
 
 ```js
 splatRenderer.autoAdvanceStochasticSample = false;
@@ -93,11 +119,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 TAA 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 TAA or 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 running with sorted rendering, set `splatRenderer.depthWrite = true` so TAA can see the Splats' depth.
+If you keep TAA or neural denoising running with sorted rendering, set `splatRenderer.depthWrite = true` so it can use the Splats' depth.

package/docs/TAAPass.md

@@ -11,13 +11,27 @@ Temporal anti-aliasing (TAA) blends each frame with the ones before it. It smoot
 
 Both render the scene themselves and need no velocity buffer or other scene setup.
 
+## MSAA
+
+The third constructor argument, `msaa`, enables 4× MSAA with `true` or disables it with `false` (default):
+
+```js
+const taa = new TAANode(scene, camera, true);
+// With WebGLRenderer: new TAAPass(scene, camera, true).
+// MSAA is disabled when the argument is omitted or false.
+```
+
+Four samples use the same stochastic coverage as the [experimental neural denoiser](NeuralDenoiseNode.md): one scene render into a 4× MSAA target, followed by the usual TAA accumulation. This reduces input noise with higher GPU time and memory use. History targets remain single-sampled, and moving objects are still not tracked.
+
+On WebGL2, including the WebGL fallback, MSAA requires `OES_sample_variables`. Check `renderer.getContext().getExtension("OES_sample_variables")` before enabling MSAA; leave it disabled when the extension is unavailable. Unsupported configurations throw an error. The MSAA setting is fixed for the node or pass's lifetime; dispose it and create another to change it.
+
 ## Before you start
 
 - **One camera.** A `PerspectiveCamera` or `OrthographicCamera`, including custom projections, scaled camera rigs, reversed depth, and logarithmic depth. WebXR is not supported.
-- **Camera movement only.** Moving objects and changes to individual Splats are not tracked, and may leave a faint trail.
+- **Camera movement only.** Moving objects and changes to individual Splats are not tracked, and may leave a faint trail. Try the [experimental neural denoiser](NeuralDenoiseNode.md) to help reduce these trails.
 - **Stencil follows your renderer.** Create the Three.js renderer with `stencil: true` and stencil masks work as they do without TAA, including the stencil settings on your Splat renderer's `material`.
 - **Reset after a jump.** Call `taa.reset()` after a camera cut or after replacing the scene. Resizing resets automatically.
-- **Keep rendering while the image settles.** With on-demand rendering, render several more frames after each change. The viewer renders 32.
+- **Keep rendering while the image settles.** With on-demand rendering, render several more frames after each change.
 
 ## TAAPass (WebGLRenderer)
 
@@ -49,7 +63,7 @@ renderer.setAnimationLoop(() => {
 // taa.dispose();
 ```
 
-Dispose the passes as well as the composer when you are done. The repository's `examples/viewer/viewerTAA.js` uses this setup.
+Dispose the passes as well as the composer when you are done.
 
 ### Add effects
 
@@ -129,6 +143,8 @@ const pipeline = new RenderPipeline(renderer, color.add(bloom(color, 0.6, 0.4, 0
 
 `TAANode` has the same `depthTexture`, `projectionMatrix`, and tuning properties as `TAAPass`.
 
+With four samples on native WebGPU, `depthTexture` is multisampled. Read it with TSL `texture(taa.depthTexture).load(pixel)` to select sample 0, as TAA does internally; filtered depth sampling is not supported. Both WebGL paths expose resolved, single-sampled depth.
+
 ## Color and tone mapping
 
 **`TAAPass`** shows Splats with the same colors as `WebGLRenderer` drawing straight to the canvas.
@@ -147,6 +163,7 @@ Both keep colors brighter than white, so effects such as Bloom work as expected.
 | --- | --- | --- |
 | `scene` | Constructor scene | Scene to render; call `reset()` when replacing it |
 | `camera` | Constructor camera | Camera to render with; call `reset()` when replacing it |
+| `msaa` | `false` | Read-only. Whether 4× MSAA is enabled, selected in the constructor |
 | `depthTexture` | Read-only | Scene depth of the current frame |
 | `projectionMatrix` | Read-only | Projection that matches `depthTexture` |
 | `depthThreshold` | `0.0005` | Depth change above which a pixel's earlier frames are discarded |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaussian-splat-lite",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "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",
@@ -21,16 +21,16 @@
     }
   },
   "scripts": {
-    "build": "npm run build:production && npm run build:dev && npm run build:types:cjs",
-    "build:dev": "vite build --mode dev-es && vite build --mode dev-cjs",
-    "build:production": "vite build --mode production-es && vite build --mode production-cjs",
-    "build:site": "vite build --config vite.site.config.ts",
-    "build:types:cjs": "node scripts/build-cjs-types.js",
+    "build": "vite build --mode production-es && vite build --mode production-cjs && vite build --mode dev-es && vite build --mode dev-cjs && npm run build:types",
+    "build:dev": "vite build --mode dev-es && vite build --mode dev-cjs && npm run build:types",
+    "build:production": "vite build --mode production-es && vite build --mode production-cjs && npm run build:types",
+    "build:site": "vite build --config vite.site.config.js",
+    "build:types": "node scripts/check-declarations.js && node scripts/build-types.js",
     "build:wasm": "node rust/build_wasm.js",
-    "check": "tsc --noEmit",
+    "check": "node scripts/check-js.js && tsc --noEmit && node scripts/check-declarations.js",
     "check:rust": "cargo fmt --manifest-path rust/Cargo.toml --all -- --check",
     "clean": "rm -rf dist/ node_modules/ rust/target/ rust/gaussian-splat-rs/pkg/",
-    "dev": "vite --config vite.site.config.ts --host",
+    "dev": "vite --config vite.site.config.js --host",
     "format": "biome format .",
     "format:fix": "biome format . --fix",
     "lint": "biome check .",
@@ -40,7 +40,7 @@
     "release:check": "npm run build:wasm && npm run build:site && npm run pack:check",
     "start": "npm run dev",
     "test": "npm run test:js && npm run test:rust",
-    "test:js": "node --no-warnings --loader ts-node/esm --test test/*.test.ts",
+    "test:js": "node --test test/*.test.js",
     "test:rust": "cargo test --manifest-path rust/Cargo.toml --workspace --locked"
   },
   "files": [
@@ -75,11 +75,9 @@
     "gaussian-splat-rs": "file:rust/gaussian-splat-rs/pkg",
     "publint": "0.3.24",
     "three": "0.186.0",
-    "ts-node": "10.9.2",
     "typescript": "^5.7.3",
     "vite": "^6.0.11",
     "vite-plugin-arraybuffer": "^0.1.4",
-    "vite-plugin-dts": "^4.5.4",
     "vite-plugin-glsl": "^1.3.1"
   },
   "peerDependencies": {

package/dist/types/capture/sceneView.d.cts

@@ -1,3 +0,0 @@
-import * as THREE from "three";
-/** Filter capture data without changing visibility while sorting is pending. */
-export declare function captureSceneView(scene: THREE.Scene, hideObjects: readonly THREE.Object3D[]): THREE.Scene;

package/dist/types/capture/sceneView.d.ts

@@ -1,3 +0,0 @@
-import * as THREE from "three";
-/** Filter capture data without changing visibility while sorting is pending. */
-export declare function captureSceneView(scene: THREE.Scene, hideObjects: readonly THREE.Object3D[]): THREE.Scene;

package/dist/types/loaders/stream/StreamByteBudget.d.cts

@@ -1,7 +0,0 @@
-/** Bound pending copies while allowing one oversized item to make progress. */
-export declare class StreamByteBudget {
-    readonly limit: number;
-    used: number;
-    constructor(limit: number, used?: number);
-    reserve(bytes: number): boolean;
-}

package/dist/types/loaders/stream/StreamByteBudget.d.ts

@@ -1,7 +0,0 @@
-/** Bound pending copies while allowing one oversized item to make progress. */
-export declare class StreamByteBudget {
-    readonly limit: number;
-    used: number;
-    constructor(limit: number, used?: number);
-    reserve(bytes: number): boolean;
-}

package/dist/types/rendering/tsl/tslCompat.d.cts

@@ -1,68 +0,0 @@
-import { Camera, Texture } from 'three';
-import { ComputeNode, IndirectStorageBufferAttribute, Node, NodeBuilder, StorageBufferAttribute, StorageBufferNode, TextureNode, WorkgroupInfoNode } from 'three/webgpu';
-import * as TSL from "three/tsl";
-declare module "three/src/nodes/core/Node.js" {
-    interface IntegerExtensions<TInteger> {
-        min(value: Node<TInteger> | number): Node<TInteger>;
-        max(value: Node<TInteger> | number): Node<TInteger>;
-    }
-    interface IntOrVecExtensions<TNodeType> {
-        shiftRight(value: Node<TNodeType> | number): Node<TNodeType>;
-        clamp(low: Node<TNodeType>, high: Node<TNodeType>): Node<TNodeType>;
-    }
-    interface NumOrBoolVec4Extensions<TNumOrBool> {
-        element(index: Node<"int"> | Node<"uint"> | number): Node<TNumOrBool>;
-    }
-    interface Mat4Extensions {
-        element(index: Node<"int"> | Node<"uint"> | number): Node<"vec4">;
-    }
-    interface FloatOrVecExtensions<TNodeType> {
-        negateAssign(): Node<TNodeType>;
-    }
-}
-type FloatToUint = {
-    float: "uint";
-    vec2: "uvec2";
-    vec3: "uvec3";
-    vec4: "uvec4";
-};
-type UintToFloat = {
-    uint: "float";
-    uvec2: "vec2";
-    uvec3: "vec3";
-    uvec4: "vec4";
-};
-type UintWorkgroup = WorkgroupInfoNode & {
-    element(index: Node<"uint"> | Node<"int"> | number): Node<"uint">;
-    setName(name: string): UintWorkgroup;
-};
-type Compatibility = {
-    convertColorSpace(value: Node<"vec4">, source: string, target: string): Node<"vec4">;
-    floatBitsToUint<T extends keyof FloatToUint>(value: Node<T>): Node<FloatToUint[T]>;
-    uintBitsToFloat<T extends keyof UintToFloat>(value: Node<T>): Node<UintToFloat[T]>;
-    packHalf2x16(value: Node<"vec2">): Node<"uint">;
-    unpackHalf2x16(value: Node<"uint">): Node<"vec2">;
-    packSnorm2x16(value: Node<"vec2">): Node<"uint">;
-    unpackSnorm2x16(value: Node<"uint">): Node<"vec2">;
-    storage(value: StorageBufferAttribute, type: "uint", count?: number): StorageBufferNode<"uint">;
-    workgroupArray(type: "uint", count: number): UintWorkgroup;
-    builtin(name: "gl_ViewID_OVR"): Node<"uint">;
-    countOneBits(value: Node<"uint">): Node<"uint">;
-    ivec2: typeof TSL.ivec2 & ((x: Node<"uint">, y: Node<"uint">) => Node<"ivec2">);
-    ivec3: typeof TSL.ivec3 & ((x: Node<"uint">, y: Node<"uint">, z: Node<"uint">) => Node<"ivec3">);
-    Loop: typeof TSL.Loop & (<Name extends string, Type extends "int" | "uint">(params: {
-        name: Name;
-        type: Type;
-        start: Node<Type>;
-        end: Node<Type>;
-        condition: string;
-    }, callback: (inputs: Record<Name, Node<Type>>) => void) => ReturnType<typeof TSL.Loop>);
-};
-export declare const N: Omit<typeof TSL, keyof Compatibility> & Compatibility;
-/** Packed integer texture loads are incorrectly declared as vec4 upstream. */
-export declare function uintTexture(texture: Texture): TextureNode<"uvec4">;
-/** NodeBuilder.camera is present when building a material shader. */
-export declare function materialCamera(builder: NodeBuilder): Camera;
-/** r186 supports an indirect attribute, but its declaration lists only counts. */
-export declare function setIndirectDispatch(node: ComputeNode, dispatch: IndirectStorageBufferAttribute): void;
-export {};

package/dist/types/rendering/tsl/tslCompat.d.ts

@@ -1,68 +0,0 @@
-import { Camera, Texture } from 'three';
-import { ComputeNode, IndirectStorageBufferAttribute, Node, NodeBuilder, StorageBufferAttribute, StorageBufferNode, TextureNode, WorkgroupInfoNode } from 'three/webgpu';
-import * as TSL from "three/tsl";
-declare module "three/src/nodes/core/Node.js" {
-    interface IntegerExtensions<TInteger> {
-        min(value: Node<TInteger> | number): Node<TInteger>;
-        max(value: Node<TInteger> | number): Node<TInteger>;
-    }
-    interface IntOrVecExtensions<TNodeType> {
-        shiftRight(value: Node<TNodeType> | number): Node<TNodeType>;
-        clamp(low: Node<TNodeType>, high: Node<TNodeType>): Node<TNodeType>;
-    }
-    interface NumOrBoolVec4Extensions<TNumOrBool> {
-        element(index: Node<"int"> | Node<"uint"> | number): Node<TNumOrBool>;
-    }
-    interface Mat4Extensions {
-        element(index: Node<"int"> | Node<"uint"> | number): Node<"vec4">;
-    }
-    interface FloatOrVecExtensions<TNodeType> {
-        negateAssign(): Node<TNodeType>;
-    }
-}
-type FloatToUint = {
-    float: "uint";
-    vec2: "uvec2";
-    vec3: "uvec3";
-    vec4: "uvec4";
-};
-type UintToFloat = {
-    uint: "float";
-    uvec2: "vec2";
-    uvec3: "vec3";
-    uvec4: "vec4";
-};
-type UintWorkgroup = WorkgroupInfoNode & {
-    element(index: Node<"uint"> | Node<"int"> | number): Node<"uint">;
-    setName(name: string): UintWorkgroup;
-};
-type Compatibility = {
-    convertColorSpace(value: Node<"vec4">, source: string, target: string): Node<"vec4">;
-    floatBitsToUint<T extends keyof FloatToUint>(value: Node<T>): Node<FloatToUint[T]>;
-    uintBitsToFloat<T extends keyof UintToFloat>(value: Node<T>): Node<UintToFloat[T]>;
-    packHalf2x16(value: Node<"vec2">): Node<"uint">;
-    unpackHalf2x16(value: Node<"uint">): Node<"vec2">;
-    packSnorm2x16(value: Node<"vec2">): Node<"uint">;
-    unpackSnorm2x16(value: Node<"uint">): Node<"vec2">;
-    storage(value: StorageBufferAttribute, type: "uint", count?: number): StorageBufferNode<"uint">;
-    workgroupArray(type: "uint", count: number): UintWorkgroup;
-    builtin(name: "gl_ViewID_OVR"): Node<"uint">;
-    countOneBits(value: Node<"uint">): Node<"uint">;
-    ivec2: typeof TSL.ivec2 & ((x: Node<"uint">, y: Node<"uint">) => Node<"ivec2">);
-    ivec3: typeof TSL.ivec3 & ((x: Node<"uint">, y: Node<"uint">, z: Node<"uint">) => Node<"ivec3">);
-    Loop: typeof TSL.Loop & (<Name extends string, Type extends "int" | "uint">(params: {
-        name: Name;
-        type: Type;
-        start: Node<Type>;
-        end: Node<Type>;
-        condition: string;
-    }, callback: (inputs: Record<Name, Node<Type>>) => void) => ReturnType<typeof TSL.Loop>);
-};
-export declare const N: Omit<typeof TSL, keyof Compatibility> & Compatibility;
-/** Packed integer texture loads are incorrectly declared as vec4 upstream. */
-export declare function uintTexture(texture: Texture): TextureNode<"uvec4">;
-/** NodeBuilder.camera is present when building a material shader. */
-export declare function materialCamera(builder: NodeBuilder): Camera;
-/** r186 supports an indirect attribute, but its declaration lists only counts. */
-export declare function setIndirectDispatch(node: ComputeNode, dispatch: IndirectStorageBufferAttribute): void;
-export {};