gaussian-splat-lite 1.2.0 → 1.2.2

package/docs/SplatLoader.md

@@ -2,7 +2,7 @@
 
 [Back to documentation](../README.md#documentation)
 
-`SplatLoader` follows the Three.js `Loader` API. Load a model as `Splats` data, then use `parse()` to create a scene object.
+`SplatLoader` works like other Three.js loaders. It loads a model as [Splats](Splats.md) data, and `parse()` turns that data into a `SplatMesh` for your scene. The format is detected automatically.
 
 ```js
 import { SplatLoader } from "gaussian-splat-lite";
@@ -16,7 +16,7 @@ const splat = loader.parse(decoded);
 scene.add(splat);
 ```
 
-The callback form matches the normal Three.js Loader pattern:
+The callback form matches the usual Three.js pattern:
 
 ```js
 loader.load(
@@ -27,7 +27,13 @@ loader.load(
 );
 ```
 
-`loadAsync(url, onProgress?, signal?)` accepts an optional `AbortSignal`. Use it to cancel loading:
+If you do not need the loader API, `new SplatMesh({ url })` loads a model in one step; see [SplatMesh](SplatMesh.md).
+
+For large RAD scenes with levels of detail, use [RadStreamScheduler](RadStreamScheduler.md). For SOG `lod-meta.json` scenes, use [SogStreamScheduler](SogStreamScheduler.md).
+
+## Cancel loading
+
+`loadAsync(url, onProgress?, signal?)` accepts an optional `AbortSignal`:
 
 ```js
 const controller = new AbortController();
@@ -35,26 +41,25 @@ const loading = loader.loadAsync("/assets/model.sog", undefined, controller.sign
 controller.abort(); // `loading` rejects with the signal's reason.
 ```
 
-`loader.abort()` cancels every load the loader has in progress; loads started afterwards are not affected. For `Splats` or `SplatMesh`, call `dispose()` to cancel a pending load.
-
-For large RAD scenes with levels of detail, use [RadStreamScheduler](RadStreamScheduler.md).
-For `lod-meta.json` scenes, use [SogStreamScheduler](SogStreamScheduler.md).
+`loader.abort()` cancels every load the loader has in progress; loads started afterwards are not affected. For a `Splats` or `SplatMesh` that is still loading, call its `dispose()`.
 
 ## Loading progress
 
-`onProgress` receives a `SplatProgressEvent` (a `ProgressEvent` with a `stage` field). This also applies to `Splats` and `SplatMesh`:
+`onProgress` receives a `SplatProgressEvent`: a standard `ProgressEvent` with an extra `stage` field. `Splats` and `SplatMesh` report progress the same way.
 
 | `stage` | `loaded` / `total` |
 | --- | --- |
-| `download` | Bytes read or downloaded; `total === 0` means unknown size |
-| `postDecode` | Splats processed by the configured `postDecode` program |
-| `optimize` | Completed work units for Morton ordering and bounding-box calculation |
+| `download` | Bytes read or downloaded; `total === 0` means the size is unknown |
+| `postDecode` | Splats processed by your [`postDecode`](PostDecode.md) program; skipped when none is set |
+| `optimize` | Steps completed while preparing the model for rendering |
+
+Progress starts again from zero for each stage. Use `event.loaded / event.total` when `event.lengthComputable` is true. It measures completed work, not time.
 
-Progress restarts for each stage. Use `event.loaded / event.total` when `event.lengthComputable` is true. `postDecode` is skipped when no program is configured; empty work reports completion immediately. Percentages describe completed work, not elapsed time. Download completion can precede the end of decoding; wait for `loadAsync()` or `.initialized` to resolve before using the model.
+The model is ready when `loadAsync()` or `.initialized` resolves, which can be a little after the download reaches 100%.
 
 ## Local split files
 
-Single `.sog` and `.rad` files need only `file`. For a local SOG `meta.json` with external `.webp` images, supply those images through `resolveFile`. The same option resolves external RAD `.radc` pages:
+A single `.sog` or `.rad` file needs only `file`. Some models are split across several files: a SOG `meta.json` with `.webp` images, or a RAD file with `.radc` pages. For these, pass the main file as `file` and supply the others through `resolveFile`:
 
 ```js
 import { SplatMesh } from "gaussian-splat-lite";
@@ -75,4 +80,4 @@ scene.add(mesh);
 await mesh.initialized;
 ```
 
-A resolver may return a URL, `Blob`, `Uint8Array`, or `ArrayBuffer`, directly or as a promise. For subfolders, match the paths referenced by the model.
+`resolveFile` is called with each file name the model refers to. Return a URL, `Blob`, `Uint8Array`, or `ArrayBuffer`, directly or as a promise. If the model refers to files in subfolders, match those paths.

package/docs/SplatMesh.md

@@ -2,15 +2,19 @@
 
 [Back to documentation](../README.md#documentation)
 
-`SplatMesh` is a `THREE.Object3D` with standard transforms, visibility, layers, and children.
+A Splat model in your scene. `SplatMesh` is a `THREE.Object3D`, so position, rotation, scale, visibility, layers, and children work as usual.
 
-```ts
-new SplatMesh(options?: SplatMeshOptions)
+```js
+import { SplatMesh } from "gaussian-splat-lite";
+
+const splat = new SplatMesh({ url: "/assets/model.spz" });
+scene.add(splat);
+await splat.initialized;
 ```
 
 ## Loading
 
-Use `url` for remote files. For a local PLY/SPZ/SOG/RAD file:
+Use `url` for a remote file. For a local PLY, SPZ, SOG, or RAD file:
 
 ```js
 const file = fileInput.files[0];
@@ -19,68 +23,85 @@ scene.add(splat);
 await splat.initialized;
 ```
 
-`file` accepts a `File` or `Blob`. For bytes, use `fileBytes: bytes`; `fileName` or `fileType` can supply an explicit format hint for any input.
+`file` accepts a `File` or `Blob`. For data already in memory, use `fileBytes`. The format is detected from the file name; pass `fileName` or [`fileType`](SplatFileType.md) when there is no name to go by.
+
+Splats are reordered while loading, so their indices differ from the order in the file; see [data rules](Splats.md#data-rules).
 
-Loaded indices may differ from file order; see [data rules](Splats.md#data-rules).
+For large streamed scenes, use [RadStreamScheduler](RadStreamScheduler.md) or [SogStreamScheduler](SogStreamScheduler.md) instead.
 
 ## Options
 
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
-| `url` | `string` | `undefined` | PLY/SPZ/SOG/RAD file or SOG metadata URL |
+| `url` | `string` | `undefined` | PLY/SPZ/SOG/RAD file or SOG `meta.json` URL |
 | `file` | `Blob` (including `File`) | `undefined` | Local file |
 | `fileBytes` | `Uint8Array \| ArrayBuffer` | `undefined` | Complete file data in memory |
-| `fileType` | `SplatFileType` | Inferred from name | Explicitly selects `PLY`, `SPZ`, `SOG`, or `RAD` |
-| `fileName` | `string` | `File.name` when available | Supplies a name for inferring the input format |
-| `resolveFile` | `SplatFileResolver` | `undefined` | Resolves external SOG images or RAD pages by metadata filename; see [local split files](SplatLoader.md#local-split-files) |
-| `postDecode` | `SplatPostDecodeProgram` | `undefined` | Apply a [load-time transform](PostDecode.md) to each Splat |
-| `splats` | `Splats` | New `Splats` | Uses an existing `Splats` instance |
-| `onProgress` | `(event: SplatProgressEvent) => void` | `undefined` | [Per-stage loading progress](SplatLoader.md#loading-progress) callback |
-| `onLoad` | `(mesh) => void \| Promise<void>` | `undefined` | Called after initialization completes |
-| `editable` | `boolean` | `true` | Allow scene-wide and model-specific region edits |
-| `raycastable` | `boolean` | `true` | Participates in Three.js raycasting |
-| `minRaycastOpacity` | `number` | `0.15` | Ignore more transparent areas when picking; higher values narrow the hit area |
-| `onFrame` | `({ mesh, time, deltaTime }) => void` | `undefined` | Called before each model update; use for animation |
-
-Choose at most one of `url`, `file`, `fileBytes`, or `splats`; mixing inputs throws.
-
-## Common properties
+| `fileType` | `SplatFileType` | Detected from the name | Set the format explicitly: `PLY`, `SPZ`, `SOG`, or `RAD` |
+| `fileName` | `string` | `File.name` when available | Name used to detect the format |
+| `resolveFile` | `SplatFileResolver` | `undefined` | Supply the extra files of a split SOG or RAD model; see [local split files](SplatLoader.md#local-split-files) |
+| `postDecode` | `SplatPostDecodeProgram` | `undefined` | [Change each Splat while loading](PostDecode.md) |
+| `splats` | `Splats` | New `Splats` | Use existing [Splats](Splats.md) data instead of loading |
+| `onProgress` | `(event: SplatProgressEvent) => void` | `undefined` | [Loading progress](SplatLoader.md#loading-progress) callback |
+| `onLoad` | `(mesh) => void \| Promise<void>` | `undefined` | Called when loading completes |
+| `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 |
+
+Choose at most one of `url`, `file`, `fileBytes`, or `splats`; combining them throws.
+
+## Properties
 
 | Property | Type / default | Description |
 | --- | --- | --- |
-| `initialized` | `Promise<SplatMesh>` | Resolves after loading and the `onLoad` callback |
-| `isInitialized` | `boolean` | Whether initialization has completed |
+| `initialized` | `Promise<SplatMesh>` | Resolves when loading and the `onLoad` callback have finished |
+| `isInitialized` | `boolean` | Whether loading has finished |
 | `numSplats` | `number` | Current Splat count |
-| `recolor` | `THREE.Color(1, 1, 1)` | RGB multiplier applied to the entire object |
-| `opacity` | `1` | Opacity multiplier applied to the entire object |
-| `maxSh` | `3` | Limit view-dependent color detail; `0` uses base color only |
-| `edits` | `SplatEdit[] \| null` | Explicit edits applied only to this mesh |
-| `splats` | `Splats \| undefined` | Current underlying Splat data |
-| `needsUpdate` | `boolean` setter | Set to `true` to force a refresh; `false` does nothing |
+| `recolor` | `THREE.Color(1, 1, 1)` | Color multiplier for the whole model |
+| `opacity` | `1` | Opacity multiplier for the whole model |
+| `maxSh` | `3` | Limit view-dependent color detail; `0` uses the base color only |
+| `edits` | `SplatEdit[] \| null` | Explicit list of [edits](SplatEdit.md) for this mesh |
+| `splats` | `Splats \| undefined` | The model's [Splats](Splats.md) data |
+| `needsUpdate` | `boolean` setter | Set to `true` to force a refresh |
 
-When the mesh's `Splats` is reinitialized, `initialized` and `isInitialized` follow the new load, and `onLoad` runs again once it finishes.
+Changes to the transform, `recolor`, `opacity`, `maxSh`, and edits are picked up automatically. If the mesh's `Splats` is loaded again, `initialized` and `isInitialized` follow the new load, and `onLoad` runs again when it finishes.
 
-## Common methods
+## Methods
 
 ```ts
 await mesh.initialized;
 
-mesh.getBoundingBox();      // Centers only.
-mesh.getBoundingBox(false); // Includes scale, rotation and shape at alpha 0.01.
+mesh.getBoundingBox();      // Box around the Splat centers.
+mesh.getBoundingBox(false); // Box that also covers each Splat's size and shape.
 
 mesh.forEachSplat((index, center, scales, quaternion, opacity, color) => {});
 
-mesh.updateVersion();                 // Regenerate and re-sort.
-mesh.updateVersion({ sort: false });  // Appearance only; reuse sorting.
-mesh.updateMappingVersion();          // Count or mapping changed.
 mesh.dispose();
 ```
 
-Bounds require initialization. `getBoundingBox()` returns a new `Box3` in mesh-local space; pass `false` to include Splat scale, rotation and kernel shape at a fixed source-opacity threshold of `0.01`. Splats below this threshold are omitted from these expanded bounds. These bounds do not track renderer settings, mesh opacity, streaming fades or SDF edits. Pass an existing box as the second argument, `mesh.getBoundingBox(true, target)`, to reuse it and avoid allocating a new box. Bounds include zero-scale Splats that meet the opacity threshold and ignore non-finite centers. Streamed bounds follow the visible selection, but RAD bounds may also include unselected Splats.
+### Bounding box
+
+`getBoundingBox()` returns a new `Box3` in the mesh's local space; the mesh must be initialized first. To avoid creating a box each time, pass one as the second argument: `mesh.getBoundingBox(true, target)`.
+
+- Pass `false` to cover each Splat's full size instead of only its center. Nearly transparent Splats, with opacity below `0.01`, are left out.
+- The box describes the loaded data. It does not follow renderer settings, `opacity`, streaming fades, or SDF edits.
+- For streamed models, the box follows the detail that is currently shown. With RAD it can be somewhat larger.
 
-For world-space bounds, update the world matrix and apply `mesh.matrixWorld` to the returned box.
+For a box in world space, update the world matrix and apply `mesh.matrixWorld` to the result.
 
-`mesh.dispose()` also disposes its `Splats`, including caller-supplied data. To keep shared or reusable data:
+### Forcing an update
+
+You rarely need these. They are for changes the mesh cannot detect by itself:
+
+```ts
+mesh.updateVersion();                 // Refresh the model and sort it again.
+mesh.updateVersion({ sort: false });  // Refresh appearance only; keep the sort order.
+mesh.updateMappingVersion();          // The Splat count changed.
+```
+
+### Disposing
+
+`mesh.dispose()` also disposes its `Splats`, even data you supplied yourself. To keep the data for reuse:
 
 ```js
 await mesh.initialized;
@@ -88,7 +109,7 @@ const data = mesh.splats;
 mesh.removeFromParent();
 mesh.splats = undefined;
 mesh.dispose();
-// Call data?.dispose() when no users need it anymore.
+// Call data?.dispose() when nothing uses it anymore.
 ```
 
 ## Raycasting
@@ -105,11 +126,10 @@ if (intersections.length > 0) {
 }
 ```
 
-Requires `raycastable: true`. Picking may return no hits during initial setup. Streaming models can be picked, but hits do not follow their display fades.
-
-Picking first checks cached block bounds at a fixed source-opacity threshold of `0.01`. Lowering `minRaycastOpacity` below `0.01` does not expand these bounds, so more transparent areas outside them cannot be picked.
-
-Hits include `index` for reading the current Splat and `sourceIndex` for its original source ID (`SplatIntersection` in TypeScript). Streamed indices can change with the visible selection. RAD source IDs are file-global node indices; streamed SOG source IDs are indices within the hit batch's source chunk.
+- The model needs `raycastable: true`, the default. Picking may return nothing while the model is still being set up.
+- Each hit has an `index`, for reading the Splat from the current data, and a `sourceIndex`, its ID in the original file (`SplatIntersection` in TypeScript).
+- Values of `minRaycastOpacity` below `0.01` have limited effect: areas that transparent may not be pickable.
+- Streamed models can be picked. Hits ignore their display fades, and an `index` can change as the shown detail changes. For RAD, `sourceIndex` is the node index within the whole file; for streamed SOG, it is the index within the chunk file the hit Splat was loaded from.
 
 ## Scene integration
 
@@ -123,8 +143,8 @@ const splat = new SplatMesh({
 scene.add(splat);
 ```
 
-If `onFrame` throws, the current update stops and the error propagates through the renderer's update/render call. Changes already made by the callback are not rolled back.
+If `onFrame` throws, the error comes out of the render or `update()` call that ran it. Changes the callback already made are kept.
 
-For GIS/ECEF scenes, keep model coordinates local and put large offsets in the mesh transform. This helps preserve detail; precision already lost in the source file cannot be restored.
+For GIS/ECEF scenes, keep the model's own coordinates small and put the large offset in the mesh transform. This preserves detail; precision already lost in the source file cannot be restored.
 
-For models using `+Y` down and `+Z` forward, use `splat.quaternion.set(1, 0, 0, 0)` to rotate 180° around X.
+For models with `+Y` down and `+Z` forward, use `splat.quaternion.set(1, 0, 0, 0)` to turn them 180° around X.

package/docs/Splats.md

@@ -2,7 +2,9 @@
 
 [Back to documentation](../README.md#documentation)
 
-`Splats` stores decoded Splat data. Wait for initialization before reading:
+`Splats` holds the data of a loaded model. Every `SplatMesh` has one as `mesh.splats`. Use it to read individual Splats, or to share one model's data between meshes.
+
+Wait for loading to finish before reading:
 
 ```js
 await splat.initialized;
@@ -17,42 +19,47 @@ The constructor and `initialize()` accept `SplatsOptions`:
 
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
-| `url` | `string` | `undefined` | PLY/SPZ/SOG/RAD file or SOG metadata URL |
+| `url` | `string` | `undefined` | PLY/SPZ/SOG/RAD file or SOG `meta.json` URL |
 | `file` | `Blob` (including `File`) | `undefined` | Local file |
-| `fileBytes` | `Uint8Array \| ArrayBuffer` | `undefined` | In-memory file data |
-| `fileType` | `SplatFileType` | Inferred from name | Explicit file format |
-| `fileName` | `string` | `File.name` when available | Name used to infer the input format |
-| `resolveFile` | `SplatFileResolver` | `undefined` | Resolves external SOG images or RAD pages by metadata filename; see [local split files](SplatLoader.md#local-split-files) |
-| `postDecode` | `SplatPostDecodeProgram` | `undefined` | Apply a [load-time transform](PostDecode.md) to each Splat |
-| `onProgress` | `(event: SplatProgressEvent) => void` | `undefined` | [Per-stage loading progress](SplatLoader.md#loading-progress) callback |
-
-Choose at most one of `url`, `file`, or `fileBytes`; mixing inputs throws.
+| `fileBytes` | `Uint8Array \| ArrayBuffer` | `undefined` | Complete file data in memory |
+| `fileType` | `SplatFileType` | Detected from the name | Set the format explicitly |
+| `fileName` | `string` | `File.name` when available | Name used to detect the format |
+| `resolveFile` | `SplatFileResolver` | `undefined` | Supply the extra files of a split SOG or RAD model; see [local split files](SplatLoader.md#local-split-files) |
+| `postDecode` | `SplatPostDecodeProgram` | `undefined` | [Change each Splat while loading](PostDecode.md) |
+| `onProgress` | `(event: SplatProgressEvent) => void` | `undefined` | [Loading progress](SplatLoader.md#loading-progress) callback |
 
-`initialize()` returns the new `initialized` promise and replaces earlier data. Reinitializing or disposing cancels pending file loading with `AbortError`.
+Choose at most one of `url`, `file`, or `fileBytes`; combining them throws.
 
 ## Methods
 
 | API | Description |
 | --- | --- |
-| `initialized` / `isInitialized` | Asynchronous initialization state |
-| `getNumSplats()` / `getNumSh()` | Returns Splat count and available SH degree |
-| `getByteLength()` | Return memory used by the retained data arrays |
-| `getSplat(index, includeSh?)` | Read one Splat; pass `false` to skip spherical harmonics |
-| `getSourceIndex(index)` | Map a current data index to its original source ID |
-| `forEachCenter(callback)` | Iterates centers only, suitable for spatial-index construction |
+| `initialized` / `isInitialized` | Promise that resolves when loading finishes, and whether it has |
+| `initialize(options)` | Load new data from a URL, file, or bytes, replacing what was there. Returns the new `initialized` promise |
+| `getNumSplats()` / `getNumSh()` | Splat count, and the level of view-dependent color (spherical harmonics degree) the model has |
+| `getByteLength()` | Memory used by the data, in bytes |
+| `getSplat(index, includeSh?)` | Read one Splat; pass `false` to skip its view-dependent color |
+| `getSourceIndex(index)` | The Splat's ID in the original file |
+| `forEachCenter(callback)` | Visit only the center of every Splat, for example to build a spatial index |
 | `forEachSplat(callback)` | Visit every Splat |
-| `initialize(options)` | Initializes or replaces data from a URL, file, or bytes |
-| `dispose()` | Cancel pending loading and release data resources |
+| `dispose()` | Cancel loading and release the data |
+
+Calling `initialize()` again or `dispose()` cancels a load still in progress; its promise rejects with `AbortError`.
 
 ## Data rules
 
-- File data is spatially reordered after `postDecode`; indices refer to the loaded order. Use `getSourceIndex(index)` or a picking hit's `sourceIndex` for the original source ID. Passing existing `Splats` to a mesh keeps their order.
-- `getSplat()` returns new `center`, `scales`, `quaternion`, `opacity`, `color`, and `sh` (0, 3, 8, or 15 RGB coefficients for SH0/1/2/3) values on each call. Changing them does not update the source. `forEachSplat()` reuses the same objects for every Splat; clone any you need to keep after the callback returns.
-- Streamed RAD/SOG data cannot be reinitialized.
-- Read bounds through [`mesh.getBoundingBox()`](SplatMesh.md#common-methods). They update when data is reinitialized or the streaming selection changes.
+- **Indices are not file order.** Splats are reordered while loading. Use `getSourceIndex(index)`, or a picking hit's `sourceIndex`, to get the ID from the original file. Passing existing `Splats` to a mesh keeps their order.
+- **Reads return copies.** `getSplat()` returns new `center`, `scales`, `quaternion`, `opacity`, `color`, and `sh` values on each call; changing them does not change the model. `sh` holds 0, 3, 8, or 15 RGB coefficients, depending on the model's degree.
+- **`forEachSplat()` reuses its objects.** The same objects are passed for every Splat, so clone anything you want to keep after the callback returns.
+- **Streamed data is read-only.** Data from [RadStreamScheduler](RadStreamScheduler.md) or [SogStreamScheduler](SogStreamScheduler.md) cannot be reinitialized.
+- **Bounds live on the mesh.** Use [`mesh.getBoundingBox()`](SplatMesh.md#bounding-box).
+
+To change a model, use [postDecode](PostDecode.md) while loading, or [SplatMesh properties](SplatMesh.md#properties) and [SDF edits](SplatEdit.md) for display color and opacity.
+
+## After reloading data
 
-Use [postDecode](PostDecode.md) to transform data at load time, or [SplatMesh properties](SplatMesh.md#common-properties) to adjust display color and opacity.
+Data loaded with `initialize()` appears once the renderer has processed it. On WebGL this can take a few frames, and the previous data stays on screen meanwhile.
 
-Reinitialized data becomes visible after the renderer updates it and any required sorting completes. Sorted WebGL rendering keeps the previous display while waiting for an asynchronous sort. For [on-demand rendering](GaussianSplatRenderer.md#on-demand-rendering), request a redraw after initialization and connect `onDirty` to the same render scheduler. With `autoUpdate: false`, await `splatRenderer.update({ scene, camera })` before rendering.
+With [on-demand rendering](GaussianSplatRenderer.md#on-demand-rendering), request a redraw when `initialized` resolves, and connect `onDirty` to the same render request. With `autoUpdate: false`, await `splatRenderer.update({ scene, camera })` before rendering.
 
-For loading progress, cancellation, and companion files, see [SplatLoader](SplatLoader.md).
+For loading progress, cancellation, and split files, see [SplatLoader](SplatLoader.md).

package/docs/StochasticRendering.md

@@ -2,11 +2,11 @@
 
 [Back to documentation](../README.md#documentation)
 
-Stochastic rendering is an optional mode for `GaussianSplatRenderer`. It produces visible noise; use temporal anti-aliasing (TAA) to smooth the result. 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) to get a smooth image. Sorted alpha blending remains the default.
 
-Supported on WebGPU, WebGL2, and WebGPURenderer's WebGL2 fallback, including WebXR.
+It works on WebGPU, WebGL2, and `WebGPURenderer`'s WebGL2 fallback, including WebXR.
 
-## Enable stochastic rendering
+## Turn it on
 
 With an existing [GaussianSplatRenderer](GaussianSplatRenderer.md):
 
@@ -20,19 +20,15 @@ Splats are sorted from front to back by default. To skip this sorting:
 splatRenderer.stochasticSort = false;
 ```
 
-Both options can be changed at runtime. While stochastic rendering is active, transparent blending is disabled and depth testing and writing are enabled. Your `transparent`, `depthTest`, and `depthWrite` settings take effect again when you return to sorted rendering.
+Both can be changed at any time. While stochastic rendering is active, Splats are drawn without blending and with depth testing and depth writing on. Your `transparent`, `depthTest`, and `depthWrite` settings apply again when you return to sorted rendering.
 
 ## Smooth the noise
 
-Use the library's [TAAPass](TAAPass.md) with **WebGLRenderer**, or the library's **TAANode** with **WebGPURenderer** (including its WebGL2 fallback). The examples below assume an existing `renderer`, `scene`, `camera`, and `splatRenderer`, with the Splat renderer already added to the scene. They use the default `autoUpdate = true` and a single non-XR camera.
-
-The noise pattern changes on each render by default so TAA can smooth it over time. The library does not enable TAA or schedule these extra renders for you. With on-demand rendering, keep rendering while TAA accumulates.
-
-WebGPURenderer blends in Three.js's linear working color space, which makes partially transparent Splats slightly brighter than WebGLRenderer drawing directly to the canvas. `TAAPass` matches direct canvas rendering by default; see [TAAPass color space](TAAPass.md#color-space).
+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.
 
 ### WebGPURenderer: TAANode
 
-Use this setup for both native WebGPU and WebGPURenderer's WebGL2 fallback, after `await renderer.init()`:
+Use this on both WebGPU and the WebGL2 fallback, after `await renderer.init()`:
 
 ```js
 import { TAANode } from "gaussian-splat-lite";
@@ -41,8 +37,7 @@ import { RenderPipeline } from "three/webgpu";
 splatRenderer.stochastic = true;
 
 const taa = new TAANode(scene, camera);
-// Chain Bloom or other linear effects from taa here.
-// RenderPipeline applies the final tone mapping and output conversion.
+// Chain Bloom or other effects from taa here.
 const pipeline = new RenderPipeline(renderer, taa);
 
 renderer.setAnimationLoop(() => {
@@ -51,44 +46,46 @@ renderer.setAnimationLoop(() => {
 });
 ```
 
-Call `taa.reset()` after a camera cut, scene replacement, or an abrupt object change. See [TAANode](TAAPass.md#webgpurenderer-tsl-version) for behavior, supported cameras, and cleanup.
-
 ### WebGLRenderer: TAAPass
 
 ```js
 import { TAAPass } 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 composer = new EffectComposer(renderer);
+composer.addPass(taa);
+// Insert Bloom or other effects here.
+composer.addPass(new OutputPass());
+
 renderer.setAnimationLoop(() => {
   // Update controls / animation here.
-  taa.render(renderer);
+  composer.render();
 });
 ```
 
-`TAAPass` renders the scene itself, so no `RenderPass` or `OutputPass` is needed. It tracks camera movement but not object motion; call `taa.reset()` after a camera cut or scene replacement. See [TAAPass](TAAPass.md) for linear effects, depth effects, and offscreen rendering.
+`TAAPass` takes the place of `RenderPass`. On resize, call `composer.setSize(width, height)` along with the renderer.
 
-For on-demand rendering with either setup, keep rendering for several frames after camera, model, or streamed-content changes, including the Splat renderer's `onDirty` callback; the viewer uses 32. The repository's `examples/viewer/viewerTAA.js` shows both setups.
+### With either setup
+
+- 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.
+
+See [TAAPass and TAANode](TAAPass.md) for effects, depth, color, and cleanup. The repository's `examples/viewer/viewerTAA.js` shows both setups.
 
 ## Control the noise pattern
 
-To keep the noise fixed, or control samples in your own TAA integration:
+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:
 
 ```js
 splatRenderer.autoAdvanceStochasticSample = false;
-splatRenderer.stochasticSample = 0; // Keep fixed, or increment it yourself.
+splatRenderer.stochasticSample = 0; // Keep fixed, or increase it yourself.
 ```
 
-Set `autoAdvanceStochasticSample = true` to restore automatic updates.
-
-Coverage uses a 32-frame spatiotemporal blue-noise sequence on all backends.
-Each Splat keeps its own spatial offset and temporal phase, so consecutive
-samples follow the texture's time axis instead of choosing unrelated offsets.
-The temporal sequence is optimized for exponential history accumulation.
-The sequence wraps after 32 samples; this reduces temporal sampling error but
-does not guarantee a noise-free result after 32 renders. Keep advancing the
-sample once per scene render, including when using camera jitter.
+When you advance it yourself, increase it by one for each render of the scene. The patterns repeat every 32 samples; a smooth image is not guaranteed after exactly 32 renders. Set `autoAdvanceStochasticSample = true` to hand control back.
 
 ## Return to sorted rendering
 
@@ -96,11 +93,11 @@ sample once per scene render, including when using camera jitter.
 splatRenderer.stochastic = false;
 ```
 
-Switching in either direction takes effect at the next update boundary, after the current draw. WebGL backends also wait for the matching accumulator and sort. `stochasticActive` reports whether stochastic rendering is in use. Keep TAA running until it turns `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 TAA 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 Splat depth.
+If you keep TAA running with sorted rendering, set `splatRenderer.depthWrite = true` so TAA can see the Splats' depth.