gaussian-splat-lite 1.2.2 → 1.3.0

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

@@ -1,66 +1,67 @@
-import { GaussianSplatRenderer } from '../rendering/GaussianSplatRenderer.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { GaussianSplatRenderer } from "../rendering/GaussianSplatRenderer.cjs";
+import type { GaussianSplatCompatibleRenderer } from "../rendering/rendererUtils.cjs";
 export type SplatCaptureTargetOptions = {
-    width: number;
-    height: number;
-    doubleBuffer?: boolean;
-    superXY?: number;
+  width: number;
+  height: number;
+  doubleBuffer?: boolean;
+  superXY?: number;
 } & Omit<THREE.RenderTargetOptions, "stencilBuffer">;
 export interface SplatCaptureOptions {
-    splatRenderer: GaussianSplatRenderer;
-    target?: SplatCaptureTargetOptions;
+  splatRenderer: GaussianSplatRenderer;
+  target?: SplatCaptureTargetOptions;
 }
 export interface SplatCaptureCubeOptions {
-    scene: THREE.Scene;
-    worldCenter: THREE.Vector3;
-    size?: number;
-    near?: number;
-    far?: number;
-    hideObjects?: THREE.Object3D[];
-    filter?: boolean;
+  scene: THREE.Scene;
+  worldCenter: THREE.Vector3;
+  size?: number;
+  near?: number;
+  far?: number;
+  hideObjects?: THREE.Object3D[];
+  filter?: boolean;
 }
 export type SplatCaptureEnvOptions = Omit<SplatCaptureCubeOptions, "filter">;
 type SceneView = {
-    scene: THREE.Scene;
-    camera: THREE.Camera;
+  scene: THREE.Scene;
+  camera: THREE.Camera;
 };
 /** Optional offscreen capture and environment maps, independent of core rendering. */
 export declare class SplatCapture {
-    readonly splatRenderer: GaussianSplatRenderer;
-    readonly superXY: number;
-    target?: THREE.RenderTarget;
-    backTarget?: THREE.RenderTarget;
-    superPixels?: Uint8Array;
-    targetPixels?: Uint8Array;
-    private disposed;
-    private readonly captureRenderer;
-    private readonly capturePass;
-    private pending;
-    private readonly cubeRenders;
-    private lastCube;
-    private pmrem;
-    constructor({ splatRenderer, target }: SplatCaptureOptions);
-    private initializeTarget;
-    get renderer(): import('../rendering/rendererUtils.cjs').GaussianSplatCompatibleRenderer;
-    private get stencilBuffer();
-    private assertActive;
-    private enqueue;
-    private renderCapture;
-    /** Snapshots the camera now; the capture may wait for earlier ones. */
-    private targetCapture;
-    renderTarget(view: SceneView): Promise<THREE.RenderTarget>;
-    /** Reuses the returned buffer; copy it if a later read must not overwrite it. */
-    readTarget(): Promise<Uint8Array>;
-    renderReadTarget(view: SceneView): Promise<Uint8Array>;
-    private renderCube;
-    /** Validates and snapshots the center now; the capture may wait for earlier ones. */
-    private cubeCapture;
-    renderCubeMap(options: SplatCaptureCubeOptions): Promise<THREE.CubeTexture>;
-    /** Faces of the latest cube capture, in the WebGL layout on every backend. */
-    readCubeTargets(): Promise<Uint8Array[]>;
-    /** The caller owns the result; texture.dispose() also releases its render target. */
-    renderEnvMap(options: SplatCaptureEnvOptions): Promise<THREE.Texture>;
-    recurseSetEnvMap(root: THREE.Object3D, envMap: THREE.Texture): void;
-    dispose(): void;
+  readonly splatRenderer: GaussianSplatRenderer;
+  readonly superXY: number;
+  target?: THREE.RenderTarget;
+  backTarget?: THREE.RenderTarget;
+  superPixels?: Uint8Array;
+  targetPixels?: Uint8Array;
+  private disposed;
+  private readonly captureRenderer;
+  private readonly capturePass;
+  private pending;
+  private readonly cubeRenders;
+  private lastCube;
+  private pmrem;
+  constructor({ splatRenderer, target }: SplatCaptureOptions);
+  private initializeTarget;
+  get renderer(): GaussianSplatCompatibleRenderer;
+  private get stencilBuffer();
+  private assertActive;
+  private enqueue;
+  private renderCapture;
+  /** Snapshots the camera now; the capture may wait for earlier ones. */
+  private targetCapture;
+  renderTarget(view: SceneView): Promise<THREE.RenderTarget>;
+  /** Reuses the returned buffer; copy it if a later read must not overwrite it. */
+  readTarget(): Promise<Uint8Array>;
+  renderReadTarget(view: SceneView): Promise<Uint8Array>;
+  private renderCube;
+  /** Validates and snapshots the center now; the capture may wait for earlier ones. */
+  private cubeCapture;
+  renderCubeMap(options: SplatCaptureCubeOptions): Promise<THREE.CubeTexture>;
+  /** Faces of the latest cube capture, in the WebGL layout on every backend. */
+  readCubeTargets(): Promise<Uint8Array[]>;
+  /** The caller owns the result; texture.dispose() also releases its render target. */
+  renderEnvMap(options: SplatCaptureEnvOptions): Promise<THREE.Texture>;
+  recurseSetEnvMap(root: THREE.Object3D, envMap: THREE.Texture): void;
+  dispose(): void;
 }
 export {};

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

@@ -1,66 +1,67 @@
-import { GaussianSplatRenderer } from '../rendering/GaussianSplatRenderer';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { GaussianSplatRenderer } from "../rendering/GaussianSplatRenderer.js";
+import type { GaussianSplatCompatibleRenderer } from "../rendering/rendererUtils.js";
 export type SplatCaptureTargetOptions = {
-    width: number;
-    height: number;
-    doubleBuffer?: boolean;
-    superXY?: number;
+  width: number;
+  height: number;
+  doubleBuffer?: boolean;
+  superXY?: number;
 } & Omit<THREE.RenderTargetOptions, "stencilBuffer">;
 export interface SplatCaptureOptions {
-    splatRenderer: GaussianSplatRenderer;
-    target?: SplatCaptureTargetOptions;
+  splatRenderer: GaussianSplatRenderer;
+  target?: SplatCaptureTargetOptions;
 }
 export interface SplatCaptureCubeOptions {
-    scene: THREE.Scene;
-    worldCenter: THREE.Vector3;
-    size?: number;
-    near?: number;
-    far?: number;
-    hideObjects?: THREE.Object3D[];
-    filter?: boolean;
+  scene: THREE.Scene;
+  worldCenter: THREE.Vector3;
+  size?: number;
+  near?: number;
+  far?: number;
+  hideObjects?: THREE.Object3D[];
+  filter?: boolean;
 }
 export type SplatCaptureEnvOptions = Omit<SplatCaptureCubeOptions, "filter">;
 type SceneView = {
-    scene: THREE.Scene;
-    camera: THREE.Camera;
+  scene: THREE.Scene;
+  camera: THREE.Camera;
 };
 /** Optional offscreen capture and environment maps, independent of core rendering. */
 export declare class SplatCapture {
-    readonly splatRenderer: GaussianSplatRenderer;
-    readonly superXY: number;
-    target?: THREE.RenderTarget;
-    backTarget?: THREE.RenderTarget;
-    superPixels?: Uint8Array;
-    targetPixels?: Uint8Array;
-    private disposed;
-    private readonly captureRenderer;
-    private readonly capturePass;
-    private pending;
-    private readonly cubeRenders;
-    private lastCube;
-    private pmrem;
-    constructor({ splatRenderer, target }: SplatCaptureOptions);
-    private initializeTarget;
-    get renderer(): import('../rendering/rendererUtils').GaussianSplatCompatibleRenderer;
-    private get stencilBuffer();
-    private assertActive;
-    private enqueue;
-    private renderCapture;
-    /** Snapshots the camera now; the capture may wait for earlier ones. */
-    private targetCapture;
-    renderTarget(view: SceneView): Promise<THREE.RenderTarget>;
-    /** Reuses the returned buffer; copy it if a later read must not overwrite it. */
-    readTarget(): Promise<Uint8Array>;
-    renderReadTarget(view: SceneView): Promise<Uint8Array>;
-    private renderCube;
-    /** Validates and snapshots the center now; the capture may wait for earlier ones. */
-    private cubeCapture;
-    renderCubeMap(options: SplatCaptureCubeOptions): Promise<THREE.CubeTexture>;
-    /** Faces of the latest cube capture, in the WebGL layout on every backend. */
-    readCubeTargets(): Promise<Uint8Array[]>;
-    /** The caller owns the result; texture.dispose() also releases its render target. */
-    renderEnvMap(options: SplatCaptureEnvOptions): Promise<THREE.Texture>;
-    recurseSetEnvMap(root: THREE.Object3D, envMap: THREE.Texture): void;
-    dispose(): void;
+  readonly splatRenderer: GaussianSplatRenderer;
+  readonly superXY: number;
+  target?: THREE.RenderTarget;
+  backTarget?: THREE.RenderTarget;
+  superPixels?: Uint8Array;
+  targetPixels?: Uint8Array;
+  private disposed;
+  private readonly captureRenderer;
+  private readonly capturePass;
+  private pending;
+  private readonly cubeRenders;
+  private lastCube;
+  private pmrem;
+  constructor({ splatRenderer, target }: SplatCaptureOptions);
+  private initializeTarget;
+  get renderer(): GaussianSplatCompatibleRenderer;
+  private get stencilBuffer();
+  private assertActive;
+  private enqueue;
+  private renderCapture;
+  /** Snapshots the camera now; the capture may wait for earlier ones. */
+  private targetCapture;
+  renderTarget(view: SceneView): Promise<THREE.RenderTarget>;
+  /** Reuses the returned buffer; copy it if a later read must not overwrite it. */
+  readTarget(): Promise<Uint8Array>;
+  renderReadTarget(view: SceneView): Promise<Uint8Array>;
+  private renderCube;
+  /** Validates and snapshots the center now; the capture may wait for earlier ones. */
+  private cubeCapture;
+  renderCubeMap(options: SplatCaptureCubeOptions): Promise<THREE.CubeTexture>;
+  /** Faces of the latest cube capture, in the WebGL layout on every backend. */
+  readCubeTargets(): Promise<Uint8Array[]>;
+  /** The caller owns the result; texture.dispose() also releases its render target. */
+  renderEnvMap(options: SplatCaptureEnvOptions): Promise<THREE.Texture>;
+  recurseSetEnvMap(root: THREE.Object3D, envMap: THREE.Texture): void;
+  dispose(): void;
 }
 export {};

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

@@ -1,13 +1,13 @@
-import * as THREE from "three";
+import type * as THREE from "three";
 /** Blend in output space like the canvas, then convert to texture storage. */
 export declare class WebGLCapture {
-    private readonly renderer;
-    private readonly depthTexture;
-    private readonly target;
-    private readonly camera;
-    private readonly material;
-    private readonly quad;
-    constructor(renderer: THREE.WebGLRenderer);
-    render(scene: THREE.Scene, camera: THREE.Camera): void;
-    dispose(): void;
+  private readonly renderer;
+  private readonly depthTexture;
+  private readonly target;
+  private readonly camera;
+  private readonly material;
+  private readonly quad;
+  constructor(renderer: THREE.WebGLRenderer);
+  render(scene: THREE.Scene, camera: THREE.Camera): void;
+  dispose(): void;
 }

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

@@ -1,13 +1,13 @@
-import * as THREE from "three";
+import type * as THREE from "three";
 /** Blend in output space like the canvas, then convert to texture storage. */
 export declare class WebGLCapture {
-    private readonly renderer;
-    private readonly depthTexture;
-    private readonly target;
-    private readonly camera;
-    private readonly material;
-    private readonly quad;
-    constructor(renderer: THREE.WebGLRenderer);
-    render(scene: THREE.Scene, camera: THREE.Camera): void;
-    dispose(): void;
+  private readonly renderer;
+  private readonly depthTexture;
+  private readonly target;
+  private readonly camera;
+  private readonly material;
+  private readonly quad;
+  constructor(renderer: THREE.WebGLRenderer);
+  render(scene: THREE.Scene, camera: THREE.Camera): void;
+  dispose(): void;
 }

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

@@ -1,17 +1,17 @@
-import { WebGPURenderer } from 'three/webgpu';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { WebGPURenderer } from "three/webgpu";
 /** Blend in working space, then convert to texture storage. */
 export declare class WebGPUCapture {
-    private readonly renderer;
-    private readonly depthTexture;
-    private readonly target;
-    private readonly material;
-    private readonly quad;
-    private workingColorSpace;
-    private outputColorSpace;
-    private storageColorSpace;
-    private toneMapping;
-    constructor(renderer: WebGPURenderer);
-    render(scene: THREE.Scene, camera: THREE.Camera): void;
-    dispose(): void;
+  private readonly renderer;
+  private readonly depthTexture;
+  private readonly target;
+  private readonly material;
+  private readonly quad;
+  private workingColorSpace;
+  private outputColorSpace;
+  private storageColorSpace;
+  private toneMapping;
+  constructor(renderer: WebGPURenderer);
+  render(scene: THREE.Scene, camera: THREE.Camera): void;
+  dispose(): void;
 }

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

@@ -1,17 +1,17 @@
-import { WebGPURenderer } from 'three/webgpu';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { WebGPURenderer } from "three/webgpu";
 /** Blend in working space, then convert to texture storage. */
 export declare class WebGPUCapture {
-    private readonly renderer;
-    private readonly depthTexture;
-    private readonly target;
-    private readonly material;
-    private readonly quad;
-    private workingColorSpace;
-    private outputColorSpace;
-    private storageColorSpace;
-    private toneMapping;
-    constructor(renderer: WebGPURenderer);
-    render(scene: THREE.Scene, camera: THREE.Camera): void;
-    dispose(): void;
+  private readonly renderer;
+  private readonly depthTexture;
+  private readonly target;
+  private readonly material;
+  private readonly quad;
+  private workingColorSpace;
+  private outputColorSpace;
+  private storageColorSpace;
+  private toneMapping;
+  constructor(renderer: WebGPURenderer);
+  render(scene: THREE.Scene, camera: THREE.Camera): void;
+  dispose(): void;
 }

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

@@ -1,5 +1,16 @@
-import { GaussianSplatCompatibleRenderer } from '../rendering/rendererUtils.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { GaussianSplatCompatibleRenderer } from "../rendering/rendererUtils.cjs";
 /** Packed RGBA8, with the bottom row first on every backend. */
-export declare function readPixels(renderer: GaussianSplatCompatibleRenderer, target: THREE.RenderTarget, pixels: Uint8Array, face?: number): Promise<void>;
-export declare function downsamplePixels(source: Uint8Array, width: number, height: number, superXY: number, output: Uint8Array): void;
+export declare function readPixels(
+  renderer: GaussianSplatCompatibleRenderer,
+  target: THREE.RenderTarget,
+  pixels: Uint8Array,
+  face?: number,
+): Promise<void>;
+export declare function downsamplePixels(
+  source: Uint8Array,
+  width: number,
+  height: number,
+  superXY: number,
+  output: Uint8Array,
+): void;

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

@@ -1,5 +1,16 @@
-import { GaussianSplatCompatibleRenderer } from '../rendering/rendererUtils';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { GaussianSplatCompatibleRenderer } from "../rendering/rendererUtils.js";
 /** Packed RGBA8, with the bottom row first on every backend. */
-export declare function readPixels(renderer: GaussianSplatCompatibleRenderer, target: THREE.RenderTarget, pixels: Uint8Array, face?: number): Promise<void>;
-export declare function downsamplePixels(source: Uint8Array, width: number, height: number, superXY: number, output: Uint8Array): void;
+export declare function readPixels(
+  renderer: GaussianSplatCompatibleRenderer,
+  target: THREE.RenderTarget,
+  pixels: Uint8Array,
+  face?: number,
+): Promise<void>;
+export declare function downsamplePixels(
+  source: Uint8Array,
+  width: number,
+  height: number,
+  superXY: number,
+  output: Uint8Array,
+): void;

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

@@ -1,3 +1,6 @@
-import { GaussianSplatCompatibleRenderer } from '../rendering/rendererUtils.cjs';
+import type { GaussianSplatCompatibleRenderer } from "../rendering/rendererUtils.cjs";
 /** Wrap synchronous drawing only; output state must never survive an await. */
-export declare function withCaptureState<T>(renderer: GaussianSplatCompatibleRenderer, draw: () => T): T;
+export declare function withCaptureState<T>(
+  renderer: GaussianSplatCompatibleRenderer,
+  draw: () => T,
+): T;

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

@@ -1,3 +1,6 @@
-import { GaussianSplatCompatibleRenderer } from '../rendering/rendererUtils';
+import type { GaussianSplatCompatibleRenderer } from "../rendering/rendererUtils.js";
 /** Wrap synchronous drawing only; output state must never survive an await. */
-export declare function withCaptureState<T>(renderer: GaussianSplatCompatibleRenderer, draw: () => T): T;
+export declare function withCaptureState<T>(
+  renderer: GaussianSplatCompatibleRenderer,
+  draw: () => T,
+): T;

package/dist/types/data/IndexedSplats.d.cts

@@ -1,68 +1,86 @@
-import { SplatOpacityTable } from './SplatOpacityTable.cjs';
-import { Splats, SplatsOptions } from './Splats.cjs';
-import { ReorderedSplatResult, SplatResult } from './defines.cjs';
-import { RaycastRangeCallback, SplatRaycastQuery } from './raycast.cjs';
-import { decodeSplat } from './unpack.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { SplatOpacityTable } from "./SplatOpacityTable.cjs";
+import { Splats, type SplatsOptions } from "./Splats.cjs";
+import type { ReorderedSplatResult, SplatResult } from "./defines.cjs";
+import type { RaycastRangeCallback, SplatRaycastQuery } from "./raycast.cjs";
+import type { decodeSplat } from "./unpack.cjs";
 type IndexedSplatsOptions = {
-    capacity: number;
-    layerSize: number;
-    numSh: number;
-    blockBits: number;
+  capacity: number;
+  layerSize: number;
+  numSh: number;
+  blockBits: number;
 };
 type DecodedSplat = ReturnType<typeof decodeSplat>;
 type DecodedSplatWithSh = DecodedSplat & {
-    sh: THREE.Color[];
+  sh: THREE.Color[];
 };
 /** Fixed packed storage with one visible-index contract for rendering and CPU reads.
  * Fades affect display only: records returned to picking retain their source opacity. */
 export declare abstract class IndexedSplats extends Splats {
-    readonly layerSize: number;
-    readonly numSh: 0 | 1 | 2 | 3;
-    protected readonly opacities: SplatOpacityTable;
-    protected sourceIndices: Uint32Array<ArrayBuffer>;
-    protected visibleIndices: Uint32Array;
-    private sourceArrays;
-    private sourceCenters;
-    private sourceTextures;
-    private indexTexture;
-    private readonly blockBits;
-    private disposed;
-    private readonly spatialChunks;
-    private spatialBoundsBytes;
-    constructor({ capacity, layerSize, numSh, blockBits }: IndexedSplatsOptions);
-    protected assertLive(): void;
-    initialize(options?: SplatsOptions): Promise<Splats>;
-    /** Range-based sources can materialize their visible map lazily. */
-    protected ensureIndices(): void;
-    /** Each source updates its bounds independently of the visible-index map. */
-    protected commitIndices(indices: Uint32Array): void;
-    /** Reserve index storage and mark it for upload; fill the first count entries synchronously. */
-    protected prepareIndices(count: number): Uint32Array<ArrayBuffer>;
-    /** Copies packed records. Input buffers remain caller-owned for both formats. */
-    protected writeRecords(start: number, data: ReorderedSplatResult, allocation: number): void;
-    private getStorageIndex;
-    getSourceIndex(index: number): number;
-    private checkVisibleRange;
-    getNumSh(): 0 | 1 | 2 | 3;
-    private get textureByteLength();
-    getByteLength(): number;
-    get residentBytes(): number;
-    private center;
-    copySortCenters(target: Float32Array, targetStart: number, count: number): void;
-    protected releaseSpatialBounds(start: number): void;
-    forEachRaycastRange(query: SplatRaycastQuery, callback: RaycastRangeCallback): void;
-    copySplatRecords(firstTarget: Uint32Array, secondTarget: Uint32Array, sourceStart: number, count: number): void;
-    getSplat(index: number): DecodedSplatWithSh;
-    getSplat(index: number, includeSh: true): DecodedSplatWithSh;
-    getSplat(index: number, includeSh: false): DecodedSplat;
-    getSplat(index: number, includeSh: boolean): DecodedSplat;
-    forEachCenter(callback: (index: number, x: number, y: number, z: number) => void): void;
-    forEachSplat(callback: Parameters<Splats["forEachSplat"]>[0]): void;
-    takeData(): SplatResult & {
-        sourceIds: Uint32Array;
-    };
-    setTextureUniforms(uniforms: Record<string, THREE.IUniform>): void;
-    dispose(): void;
+  readonly layerSize: number;
+  readonly numSh: 0 | 1 | 2 | 3;
+  protected readonly opacities: SplatOpacityTable;
+  protected sourceIndices: Uint32Array<ArrayBuffer>;
+  protected visibleIndices: Uint32Array;
+  private sourceArrays;
+  private sourceCenters;
+  private sourceTextures;
+  private indexTexture;
+  private readonly blockBits;
+  private disposed;
+  private readonly spatialChunks;
+  private spatialBoundsBytes;
+  constructor({ capacity, layerSize, numSh, blockBits }: IndexedSplatsOptions);
+  protected assertLive(): void;
+  initialize(options?: SplatsOptions): Promise<Splats>;
+  /** Range-based sources can materialize their visible map lazily. */
+  protected ensureIndices(): void;
+  /** Each source updates its bounds independently of the visible-index map. */
+  protected commitIndices(indices: Uint32Array): void;
+  /** Reserve index storage and mark it for upload; fill the first count entries synchronously. */
+  protected prepareIndices(count: number): Uint32Array<ArrayBuffer>;
+  /** Copies packed records. Input buffers remain caller-owned for both formats. */
+  protected writeRecords(
+    start: number,
+    data: ReorderedSplatResult,
+    allocation: number,
+  ): void;
+  private getStorageIndex;
+  getSourceIndex(index: number): number;
+  private checkVisibleRange;
+  getNumSh(): 0 | 3 | 2 | 1;
+  private get textureByteLength();
+  getByteLength(): number;
+  get residentBytes(): number;
+  private center;
+  copySortCenters(
+    target: Float32Array,
+    targetStart: number,
+    count: number,
+  ): void;
+  protected releaseSpatialBounds(start: number): void;
+  forEachRaycastRange(
+    query: SplatRaycastQuery,
+    callback: RaycastRangeCallback,
+  ): void;
+  copySplatRecords(
+    firstTarget: Uint32Array,
+    secondTarget: Uint32Array,
+    sourceStart: number,
+    count: number,
+  ): void;
+  getSplat(index: number): DecodedSplatWithSh;
+  getSplat(index: number, includeSh: true): DecodedSplatWithSh;
+  getSplat(index: number, includeSh: false): DecodedSplat;
+  getSplat(index: number, includeSh: boolean): DecodedSplat;
+  forEachCenter(
+    callback: (index: number, x: number, y: number, z: number) => void,
+  ): void;
+  forEachSplat(callback: Parameters<Splats["forEachSplat"]>[0]): void;
+  takeData(): SplatResult & {
+    sourceIds: Uint32Array;
+  };
+  setTextureUniforms(uniforms: Record<string, THREE.IUniform>): void;
+  dispose(): void;
 }
 export {};