gaussian-splat-lite 0.1.0

package/dist/types/wasm.d.cts

@@ -0,0 +1,2 @@
+export declare const WASM_MODULE: Promise<WebAssembly.Module>;
+export declare function isInitialized(): boolean;

package/dist/types/wasm.d.ts

@@ -0,0 +1,2 @@
+export declare const WASM_MODULE: Promise<WebAssembly.Module>;
+export declare function isInitialized(): boolean;

package/dist/types/worker.d.cts

@@ -0,0 +1,42 @@
+import { SplatResult } from './defines.cjs';
+declare const rpcHandlers: {
+    setSortCenters: typeof setSortCenters;
+    sortCenters32: typeof sortCenters32;
+    loadSplats: typeof loadSplats;
+    nextChunk: typeof nextChunk;
+};
+export type RpcHandlers = typeof rpcHandlers;
+declare function setSortCenters({ centers, rangeBases, rangeCounts, rangeOrigins, }: {
+    centers: Float32Array;
+    rangeBases: Uint32Array;
+    rangeCounts: Uint32Array;
+    rangeOrigins: Float64Array;
+}): {
+    numSplats: number;
+};
+declare function sortCenters32({ numSplats, cameraPosition, direction, radial, ordering, }: {
+    numSplats: number;
+    cameraPosition: [number, number, number];
+    direction: [number, number, number];
+    radial: boolean;
+    ordering: Uint32Array;
+}): {
+    activeSplats: number;
+    ordering: Uint32Array<ArrayBufferLike>;
+};
+declare function loadSplats({ url, requestHeader, withCredentials, fileBytes, fileType, pathName, chunked, chunkedLength, }: {
+    url?: string;
+    requestHeader?: Record<string, string>;
+    withCredentials?: boolean;
+    fileBytes?: Uint8Array;
+    fileType?: string;
+    pathName?: string;
+    chunked?: boolean;
+    chunkedLength?: number;
+}, { sendStatus }: {
+    sendStatus: (data: unknown) => void;
+}): Promise<SplatResult>;
+declare function nextChunk({ chunk }: {
+    chunk: Uint8Array;
+}): Promise<void>;
+export {};

package/dist/types/worker.d.ts

@@ -0,0 +1,42 @@
+import { SplatResult } from './defines';
+declare const rpcHandlers: {
+    setSortCenters: typeof setSortCenters;
+    sortCenters32: typeof sortCenters32;
+    loadSplats: typeof loadSplats;
+    nextChunk: typeof nextChunk;
+};
+export type RpcHandlers = typeof rpcHandlers;
+declare function setSortCenters({ centers, rangeBases, rangeCounts, rangeOrigins, }: {
+    centers: Float32Array;
+    rangeBases: Uint32Array;
+    rangeCounts: Uint32Array;
+    rangeOrigins: Float64Array;
+}): {
+    numSplats: number;
+};
+declare function sortCenters32({ numSplats, cameraPosition, direction, radial, ordering, }: {
+    numSplats: number;
+    cameraPosition: [number, number, number];
+    direction: [number, number, number];
+    radial: boolean;
+    ordering: Uint32Array;
+}): {
+    activeSplats: number;
+    ordering: Uint32Array<ArrayBufferLike>;
+};
+declare function loadSplats({ url, requestHeader, withCredentials, fileBytes, fileType, pathName, chunked, chunkedLength, }: {
+    url?: string;
+    requestHeader?: Record<string, string>;
+    withCredentials?: boolean;
+    fileBytes?: Uint8Array;
+    fileType?: string;
+    pathName?: string;
+    chunked?: boolean;
+    chunkedLength?: number;
+}, { sendStatus }: {
+    sendStatus: (data: unknown) => void;
+}): Promise<SplatResult>;
+declare function nextChunk({ chunk }: {
+    chunk: Uint8Array;
+}): Promise<void>;
+export {};

package/docs/GaussianSplatRenderer.md

@@ -0,0 +1,107 @@
+# GaussianSplatRenderer
+
+[Back to the API overview](../README.md#core-concepts-and-public-api)
+
+```ts
+new GaussianSplatRenderer(options: GaussianSplatRendererOptions)
+```
+
+## Basic options
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `renderer` | `THREE.WebGLRenderer` | Required | The Three.js WebGL renderer |
+| `onDirty` | `() => void` | `undefined` | Called when loading, generation, or sorting requires another render |
+| `premultipliedAlpha` | `boolean` | `true` | Uses premultiplied alpha while accumulating Splat RGB |
+| `timer` | `THREE.Timer` | New internal timer | Shares time with another animation system; caller owns and updates a supplied timer |
+| `autoUpdate` | `boolean` | `true` | Automatically checks the Splat collection each frame |
+| `preUpdate` | `boolean` | `true` | Updates before drawing; WebXR presentation automatically uses an asynchronous post-render update |
+| `accumPackedSplats` | `boolean` | `false` | Uses compressed Packed Splats for intermediate data, reducing memory at the cost of precision; changing it regenerates the accumulator on the next update |
+
+## Quality and appearance options
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `maxStdDev` | `number` | `Math.sqrt(8)` | Maximum standard deviations drawn from each Gaussian center; lower values improve speed but crop edges |
+| `minPixelRadius` | `number` | `1` | Minimum screen-space Splat radius |
+| `maxPixelRadius` | `number` | `512` | Maximum screen-space Splat radius |
+| `minAlpha` | `number` | `0.5 / 255` | Fragments below this alpha are discarded |
+| `enable2DGS` | `boolean` | `false` | Treats a Splat with exactly one zero scale axis as a 2D Gaussian |
+| `preBlurAmount` | `number` | `0` | Adds to the covariance diagonal before opacity correction |
+| `blurAmount` | `number` | `0.3` | Anti-aliasing blur amount with opacity correction |
+| `focalDistance` | `number` | `0` | Distance to the depth-of-field focal plane |
+| `apertureAngle` | `number` | `0` | Full aperture angle in radians; `0` disables depth of field |
+| `clipXY` | `number` | `1.25` | Center-clipping factor relative to the X/Y frustum boundary; `1` clips immediately outside it |
+| `focalAdjustment` | `number` | `2` | Projected Splat-size adjustment; larger values generally look sharper |
+
+## Sorting, material, and offscreen options
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `sortRadial` | `boolean` | `false` | Sorts by geometric distance when `true`, or by Z depth when `false` |
+| `minSortIntervalMs` | `number` | `0` | Minimum interval between sort calls, in milliseconds |
+| `transparent` | `boolean` | `true` | Places the Splat material in the Three.js transparent render pass |
+| `depthTest` | `boolean` | `true` | Reads the depth buffer for occlusion with regular meshes |
+| `depthWrite` | `boolean` | `false` | Writes depth; normally undesirable for transparent Splats |
+| `extraUniforms` | `Record<string, unknown>` | `undefined` | Additional values merged into the default shader uniforms |
+| `vertexShader` | `string` | Built in | Replaces the default Splat vertex shader |
+| `fragmentShader` | `string` | Built in | Replaces the default Splat fragment shader |
+| `target` | `TargetOptions` | `undefined` | Creates a dedicated offscreen render target |
+
+The `target` structure is:
+
+```ts
+type TargetOptions = {
+  width: number;
+  height: number;
+  doubleBuffer?: boolean; // false
+  superXY?: number;       // 1-4, default 1
+} & THREE.RenderTargetOptions;
+```
+
+`superXY` renders at a higher resolution and performs simple CPU averaging when `readTarget()` is called. Both `width * superXY` and `height * superXY` must be no greater than 8192.
+
+## Common properties and methods
+
+| API | Description |
+| --- | --- |
+| `update({ scene, camera })` | Manually generates and sorts Splats; returns `Promise<void>` |
+| `clearSplats()` | Clears the current display buffer without removing scene objects |
+| `render(scene, camera)` | Performs one Three.js render using this instance as the active Splat renderer |
+| `renderTarget({ scene, camera })` | Renders to the target configured in the constructor |
+| `readTarget()` | Reads the latest offscreen result as an RGBA `Uint8Array` |
+| `renderReadTarget({ scene, camera })` | Renders and reads an offscreen result |
+| `renderCubeMap(...)` | Renders a cube map from a world-space position |
+| `readCubeTargets()` | Reads RGBA bytes from all six cube faces |
+| `renderEnvMap(...)` | Renders and PMREM-prefilters an environment map |
+| `recurseSetEnvMap(root, envMap)` | Assigns an environment map to descendant `MeshStandardMaterial` instances |
+| `dispose()` | Releases materials, geometry, textures, targets, and the sorting worker |
+| `premultipliedAlpha` | A read/write property that recompiles the material when changed |
+| `accumPackedSplats` | A read/write property that switches accumulator encoding on the next update |
+
+For an on-demand render loop, connect `onDirty` to the application's render scheduler:
+
+```js
+let needsRender = true;
+
+function requestRender() {
+  needsRender = true;
+}
+
+controls.addEventListener("update", requestRender);
+
+const splatRenderer = new GaussianSplatRenderer({
+  renderer,
+  onDirty: requestRender,
+});
+scene.add(splatRenderer);
+
+renderer.setAnimationLoop((time) => {
+  controls.update(time);
+  if (!needsRender) return;
+
+  // Clear the flag before rendering so a new onDirty call is preserved.
+  needsRender = false;
+  renderer.render(scene, camera);
+});
+```

package/docs/SplatAccumulator.md

@@ -0,0 +1,44 @@
+# SplatAccumulator
+
+[Back to the API overview](../README.md#core-concepts-and-public-api)
+
+`SplatAccumulator` is the low-level GPU generation buffer used by `GaussianSplatRenderer` to combine visible `SplatMesh` objects into renderable texture arrays. Applications normally should not construct or update it directly.
+
+## Constructor
+
+```ts
+new SplatAccumulator(options?: { packedSplats?: boolean })
+```
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `packedSplats` | `boolean` | `false` | Uses compressed Packed Splats when enabled; otherwise uses normal Splats |
+
+The similarly named `GaussianSplatRenderer.accumPackedSplats` option defaults to `false`. Changing it at runtime regenerates that renderer's accumulator on the next update.
+
+## Common state
+
+| Property | Description |
+| --- | --- |
+| `numSplats` | Number of valid Splats in the current combined buffer |
+| `maxSplats` | Allocated Splat capacity |
+| `mapping` | `SplatMapping[]` entries associating each visible mesh with its buffer range and versions |
+| `version` | Combined generated-data version |
+| `mappingVersion` | Combined mesh-to-buffer mapping version |
+| `viewOrigin` / `viewDirection` | Camera position and direction used by the current generation pass |
+| `time` / `deltaTime` | Timer values used for per-frame mesh updates |
+
+## Common methods
+
+| API | Description |
+| --- | --- |
+| `getTextures()` | Returns the generated Splat data textures, or empty fallback textures before allocation |
+| `getSplatShapeTexture()` | Returns the generated Splat-shape texture |
+| `generateMapping(splatCounts)` | Assigns texture-row-aligned ranges and returns their required capacity |
+| `ensureGenerate({ maxSplats })` | Allocates or grows the generation target; returns whether a new target was created |
+| `generate({ mesh, base, count, renderer })` | Generates one mesh into its assigned accumulator range |
+| `prepareGenerate({ renderer, scene, timer, camera, previous })` | Collects visible meshes, runs frame updates, compares versions, and returns a deferred generation plan |
+| `checkVersions(mapping)` | Reports generated-data, mapping, and sorting changes relative to another mapping |
+| `dispose()` | Releases the accumulator render target |
+
+`prepareGenerate()`, `generate()`, and version management are renderer plumbing. Use `GaussianSplatRenderer.update()` for normal manual updates.

package/docs/SplatEdit.md

@@ -0,0 +1,84 @@
+# SDF color and opacity editing
+
+[Back to the API overview](../README.md#core-concepts-and-public-api)
+
+SDF edits affect RGBA only. They do not move Splat centers or invalidate an existing depth order. Available shapes are:
+
+```ts
+SplatEditSdfType.ALL
+SplatEditSdfType.PLANE
+SplatEditSdfType.SPHERE
+SplatEditSdfType.BOX
+SplatEditSdfType.ELLIPSOID
+SplatEditSdfType.CYLINDER
+SplatEditSdfType.CAPSULE
+SplatEditSdfType.INFINITE_CONE
+```
+
+The following edit affects only `splat`:
+
+```js
+import * as THREE from "three";
+import {
+  SplatEdit,
+  SplatEditRgbaBlendMode,
+  SplatEditSdf,
+  SplatEditSdfType,
+} from "gaussian-splat-lite";
+
+const edit = new SplatEdit({
+  name: "Warm sphere",
+  rgbaBlendMode: SplatEditRgbaBlendMode.MULTIPLY,
+  softEdge: 0.1,
+  sdfSmooth: 0,
+});
+
+const sphere = new SplatEditSdf({
+  type: SplatEditSdfType.SPHERE,
+  color: new THREE.Color(1, 0.5, 0.5),
+  opacity: 0.4,
+  radius: 1,
+});
+
+sphere.position.set(0, 0, 0);
+edit.add(sphere);
+splat.add(edit);
+```
+
+Adding a `SplatEdit` directly to the scene, rather than below a particular `SplatMesh`, makes it a global edit for every editable Splat mesh:
+
+```js
+scene.add(edit);
+```
+
+## SplatEdit options
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `name` | `string` | Generated | Object name |
+| `rgbaBlendMode` | `SplatEditRgbaBlendMode` | `MULTIPLY` | Component-wise multiplication or `ADD_RGBA` addition |
+| `sdfSmooth` | `number` | `0` | Smoothing amount when combining SDF shapes |
+| `softEdge` | `number` | `0` | Region-edge feathering distance |
+| `invert` | `boolean` | `false` | Inverts the entire edit region |
+| `sdfs` | `SplatEditSdf[]` | `null` | Explicit shape list; SDFs can instead be child objects |
+
+## SplatEdit methods
+
+| API | Description |
+| --- | --- |
+| `addSdf(sdf)` | Adds an SDF to the explicit `sdfs` list without adding the same object twice |
+| `removeSdf(sdf)` | Removes an SDF from the explicit `sdfs` list |
+
+`addSdf()` and `removeSdf()` manage the explicit list. When `sdfs` is not `null`, the renderer uses that list instead of traversing the `SplatEdit` child hierarchy. Use `edit.add(sdf)` and `edit.remove(sdf)` when the SDFs should instead be regular `THREE.Object3D` children.
+
+## SplatEditSdf options
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `type` | `SplatEditSdfType` | `SPHERE` | SDF shape |
+| `invert` | `boolean` | `false` | Inverts the inside and outside of the shape |
+| `opacity` | `number` | `1` | Alpha value used by the edit |
+| `color` | `THREE.Color` | White | RGB value used by the edit |
+| `radius` | `number` | `0` | Radius used by sphere, cylinder, capsule, and related shapes |
+
+An SDF extends `THREE.Object3D`; its position, rotation, and scale define the edit region. Edits execute in creation order by default, and the order can be changed through `edit.ordering`.

package/docs/SplatFileType.md

@@ -0,0 +1,30 @@
+# SplatFileType
+
+[Back to the API overview](../README.md#core-concepts-and-public-api)
+
+`SplatFileType` identifies the two file formats decoded by Gaussian-Splat-Lite:
+
+```ts
+enum SplatFileType {
+  PLY = "ply",
+  SPZ = "spz",
+}
+```
+
+The loader normally infers the type from a URL or `fileName` ending in `.ply` or `.spz`. Specify `fileType` when the input name has no recognizable extension or when loading unnamed in-memory data.
+
+```js
+import { SplatFileType, SplatMesh } from "gaussian-splat-lite";
+
+const fromUrl = new SplatMesh({
+  url: "/download/model",
+  fileType: SplatFileType.SPZ,
+});
+
+const fromMemory = new SplatMesh({
+  fileBytes: bytes,
+  fileType: SplatFileType.PLY,
+});
+```
+
+The same `fileType` option is accepted by `SplatMesh`, `Splats`, and the low-level `SplatLoader.loadInternal()` APIs.

package/docs/SplatLoader.md

@@ -0,0 +1,28 @@
+# SplatLoader
+
+[Back to the API overview](../README.md#core-concepts-and-public-api)
+
+`SplatLoader` follows the Three.js `Loader` API style. It first returns decoded `Splats`; `parse()` then wraps that source in a `SplatMesh`.
+
+```js
+import { SplatLoader } from "gaussian-splat-lite";
+
+const loader = new SplatLoader();
+const decoded = await loader.loadAsync("/assets/model.spz", (event) => {
+  console.log(event.loaded, event.total);
+});
+
+const splat = loader.parse(decoded);
+scene.add(splat);
+```
+
+The callback form matches the normal Three.js Loader pattern:
+
+```js
+loader.load(
+  "/assets/model.ply",
+  (decoded) => scene.add(loader.parse(decoded)),
+  (event) => console.log(event.loaded, event.total),
+  (error) => console.error(error),
+);
+```

package/docs/SplatMesh.md

@@ -0,0 +1,80 @@
+# SplatMesh
+
+[Back to the API overview](../README.md#core-concepts-and-public-api)
+
+`SplatMesh` extends `THREE.Object3D`, so it supports the standard `position`, `quaternion`, `scale`, `visible`, `layers`, and parent/child hierarchy APIs.
+
+```ts
+new SplatMesh(options?: SplatMeshOptions)
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `url` | `string` | `undefined` | PLY/SPZ file URL |
+| `fileBytes` | `Uint8Array \| ArrayBuffer` | `undefined` | Complete file data in memory |
+| `fileType` | `SplatFileType` | Inferred from name | Explicitly selects `PLY` or `SPZ` |
+| `fileName` | `string` | `undefined` | Supplies a name for inferring the format of byte or stream input |
+| `stream` | `ReadableStream` | `undefined` | Chunked input stream |
+| `streamLength` | `number` | `undefined` | Total stream length for progress reporting |
+| `splats` | `SplatSource` | New `Splats` | Uses an existing built-in or custom source |
+| `maxSplats` | `number` | `0` | Initial capacity for programmatic construction; grows when necessary |
+| `constructSplats` | `(splats) => void \| Promise<void>` | `undefined` | Populates `Splats` during initialization |
+| `onProgress` | `(event: ProgressEvent) => void` | `undefined` | Download or stream decoding progress callback |
+| `onLoad` | `(mesh) => void \| Promise<void>` | `undefined` | Called after initialization completes |
+| `editable` | `boolean` | `true` | Applies global and local SDF edits |
+| `raycastable` | `boolean` | `true` | Participates in Three.js raycasting |
+| `minRaycastOpacity` | `number` | `0.05` | Per-Splat kernel-alpha threshold; clips the raycast hit area at this opacity, including special-shape Splats |
+| `onFrame` | `({ mesh, time, deltaTime }) => void` | `undefined` | Called before Splat generation for a frame |
+
+Normally, choose exactly one of `url`, `fileBytes`, or `stream`. The `splats` option is intended for advanced custom sources and should not be mixed with file input.
+
+## Common properties
+
+| Property | Type / default | Description |
+| --- | --- | --- |
+| `initialized` | `Promise<SplatMesh>` | Resolves after asynchronous loading and construction |
+| `isInitialized` | `boolean` | Whether initialization has completed |
+| `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` | Maximum spherical-harmonic degree; use `0` for base color only |
+| `edits` | `SplatEdit[] \| null` | Explicit edits applied only to this mesh |
+| `splats` | `SplatSource \| undefined` | Current underlying source |
+| `needsUpdate` | `boolean` setter | Set to `true` to force Splat regeneration and depth re-sorting; `false` does nothing |
+
+## Common methods
+
+```ts
+await mesh.initialized;
+
+mesh.getBoundingBox();      // Centers only; faster.
+mesh.getBoundingBox(false); // Includes rotated and scaled Splat bounds.
+
+mesh.pushSplat(center, scales, quaternion, opacity, color);
+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();
+```
+
+`getBoundingBox()` can only be called after initialization. `pushSplat()` only affects a mesh backed by the built-in `Splats` source.
+
+## Raycasting
+
+`SplatMesh` implements the Three.js `raycast()` protocol:
+
+```js
+const raycaster = new THREE.Raycaster();
+raycaster.setFromCamera(pointer, camera);
+
+const intersections = raycaster.intersectObject(splat);
+if (intersections.length > 0) {
+  console.log(intersections[0].point, intersections[0].distance);
+}
+```
+
+Raycasting currently requires the built-in `Splats` source and `raycastable: true`. During the earliest stage of module startup, raycasting temporarily returns no intersections until the main-thread WebAssembly instance is ready.

package/docs/SplatSource.md

@@ -0,0 +1,26 @@
+# Custom SplatSource
+
+[Back to the API overview](../README.md#core-concepts-and-public-api)
+
+Advanced integrations can implement and supply a custom `SplatSource`. A source must provide both CPU center iteration and GPU texture access:
+
+```ts
+interface SplatSource {
+  needsUpdate: boolean;
+
+  dispose(): void;
+  getNumSplats(): number;
+  getNumSh(): number;
+  getSplatTextures(): readonly [
+    THREE.DataArrayTexture,
+    THREE.DataArrayTexture,
+  ];
+  getShTextures(): SplatShTextures;
+  forEachCenter(callback: (index, x, y, z) => void): void;
+  forEachSplat(callback: (index, center, scales, quaternion, opacity, color) => void): void;
+}
+
+const mesh = new SplatMesh({ splats: customSource });
+```
+
+This is an extension point for the low-level encoding. Shader construction, arbitrary per-Splat modifiers, and dynamic shader nodes are deliberately outside this interface.

package/docs/Splats.md

@@ -0,0 +1,58 @@
+# Splats
+
+[Back to the API overview](../README.md#core-concepts-and-public-api)
+
+`Splats` is the built-in mutable source. In addition to file input, it provides direct per-Splat access:
+
+```js
+const data = splat.splats;
+const item = data.getSplat(0);
+
+data.setSplat(
+  0,
+  item.center,
+  item.scales.multiplyScalar(1.1),
+  item.quaternion,
+  item.opacity,
+  item.color,
+);
+
+data.pushSplat(center, scales, quaternion, opacity, color);
+data.forEachSplat((index, center, scales, quaternion, opacity, color) => {});
+```
+
+The constructor and `reinitialize()` accept the same `SplatsOptions`:
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `url` | `string` | `undefined` | PLY/SPZ file URL |
+| `fileBytes` | `Uint8Array \| ArrayBuffer` | `undefined` | In-memory file data |
+| `fileType` | `SplatFileType` | Inferred from name | Explicit file format |
+| `fileName` | `string` | `undefined` | Name used to infer byte or stream input format |
+| `stream` | `ReadableStream` | `undefined` | Chunked input stream |
+| `streamLength` | `number` | `undefined` | Total input-stream length |
+| `maxSplats` | `number` | `0` | Initial capacity |
+| `splatArrays` | `[Uint32Array, Uint32Array]` | Empty arrays | Two pre-encoded Splat data arrays |
+| `numSplats` | `number` | Capacity | Number of valid Splats in `splatArrays` |
+| `construct` | `(splats) => void \| Promise<void>` | `undefined` | Populates the source during initialization |
+| `onProgress` | `(event: ProgressEvent) => void` | `undefined` | Loading progress callback |
+| `extra` | `Record<string, unknown>` | `{}` | Additional data such as SH arrays |
+
+File input, `splatArrays`, and `construct` serve different initialization paths and normally should not be mixed. Supplying `splatArrays` directly is a low-level encoded-data API.
+
+The main methods are:
+
+| API | Description |
+| --- | --- |
+| `initialized` / `isInitialized` | Asynchronous initialization state |
+| `getNumSplats()` / `getNumSh()` | Returns Splat count and available SH degree |
+| `getSplat(index)` | Decodes and returns one Splat |
+| `setSplat(index, ...)` | Adds or overwrites one Splat |
+| `pushSplat(...)` | Appends one Splat |
+| `forEachCenter(callback)` | Iterates centers only, suitable for spatial-index construction |
+| `forEachSplat(callback)` | Iterates and fully decodes every Splat |
+| `ensureSplats(count)` | Ensures underlying array capacity |
+| `reinitialize(options)` | Reinitializes from a file, stream, array, or construction callback |
+| `dispose()` | Releases textures and data references |
+
+After modifying low-level arrays such as `splatArrays` directly, set `data.needsUpdate = true`. Prefer `setSplat()` and `pushSplat()`, which manage capacity and update state automatically.

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "gaussian-splat-lite",
+  "version": "0.1.0",
+  "description": "A lightweight Three.js Gaussian Splatting renderer with PLY/SPZ loading, WebAssembly-accelerated sorting and raycasting, multi-Splat rendering, and high-precision GIS/ECEF coordinate support",
+  "author": "William Liu <lyz15972107087@gmail.com>",
+  "type": "module",
+  "license": "Apache-2.0",
+  "main": "./dist/gaussian-splat-lite.cjs",
+  "module": "./dist/gaussian-splat-lite.module.js",
+  "types": "./dist/types/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/index.d.mts",
+        "default": "./dist/gaussian-splat-lite.module.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.cts",
+        "default": "./dist/gaussian-splat-lite.cjs"
+      }
+    }
+  },
+  "scripts": {
+    "build": "npm run build:production && npm run build:dev && npm run build:types:cjs",
+    "build:dev": "vite build --mode dev",
+    "build:production": "vite build --mode production",
+    "build:site": "vite build --config vite.site.config.ts",
+    "build:types:cjs": "node scripts/build-cjs-types.js",
+    "build:wasm": "node rust/build_wasm.js",
+    "build:watch": "onchange 'src/**/*.{ts,glsl}' -- npm run build:dev",
+    "check": "tsc --noEmit",
+    "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": "npm run build:dev && node scripts/dev.js",
+    "format": "biome format .",
+    "format:fix": "biome format . --fix",
+    "lint": "biome check .",
+    "lint:fix": "biome check . --fix",
+    "pack:check": "npm pack --dry-run && publint",
+    "prepack": "npm run check && npm run check:rust && npm run lint && npm test && npm run build",
+    "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/utils.test.ts",
+    "test:rust": "cargo test --manifest-path rust/Cargo.toml --workspace --locked"
+  },
+  "files": [
+    "dist",
+    "docs",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "Gaussian-Splat-Lite.svg",
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "THIRD_PARTY_LICENSES.md"
+  ],
+  "engines": {
+    "node": ">=20.9"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite.git"
+  },
+  "homepage": "https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite#readme",
+  "bugs": {
+    "url": "https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "1.9.4",
+    "@types/three": "0.185.1",
+    "gaussian-splat-rs": "file:rust/gaussian-splat-rs/pkg",
+    "onchange": "7.1.0",
+    "publint": "0.3.24",
+    "three": "^0.185.1",
+    "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": {
+    "three": ">=0.185.1"
+  },
+  "keywords": [
+    "3d",
+    "3dgs",
+    "ecef",
+    "gaussian-splatting",
+    "gis",
+    "gsplats",
+    "ply",
+    "spz",
+    "three.js",
+    "threejs",
+    "webassembly",
+    "webgl"
+  ],
+  "allowScripts": {
+    "@biomejs/biome@1.9.4": true,
+    "esbuild@0.25.2": true,
+    "fsevents@2.3.3": true
+  }
+}