gaussian-splat-lite 1.2.0 → 1.2.1

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

@@ -3,9 +3,10 @@ import { Pass } from 'three/addons/postprocessing/Pass.js';
 /**
  * Temporal reprojection for WebGLRenderer, using depth and camera motion.
  * Object motion is not tracked; no velocity texture is required.
- * Owns scene capture, camera jitter, and history. By default it blends and
- * accumulates in the output color space, like direct canvas rendering, and
- * presents the result without OutputPass.
+ * Owns scene capture, camera jitter, and history. It blends and accumulates
+ * in the output color space, like direct canvas rendering, then hands the
+ * composer a working-space result. Use EffectComposer with OutputPass for
+ * output.
  */
 export declare class TAAPass extends Pass {
     scene: Scene;
@@ -18,20 +19,10 @@ export declare class TAAPass extends Pass {
     maxMotionLength: number;
     /** Increase current-frame weight for subpixel camera motion. */
     useSubpixelCorrection: boolean;
-    /**
-     * Capture and accumulate in the renderer's output color space, ready for
-     * presentation. Set false to stay in the working color space for linear
-     * effects, followed by OutputPass.
-     */
-    accumulateInOutputSpace: boolean;
     private readonly _source;
     private readonly _history;
-    private readonly _size;
     private readonly _clearColor;
     private readonly _state;
-    private _workingColorSpace;
-    private _toneMapping;
-    private _toneMappingExposure;
     private readonly _uniforms;
     private readonly _resolveMaterial;
     private readonly _copyMaterial;
@@ -45,7 +36,7 @@ export declare class TAAPass extends Pass {
     setSize(width: number, height: number): void;
     /** Discard history after a camera cut, scene replacement, or color-space change. */
     reset(): void;
-    /** Render the scene and TAA to the canvas, a target, or the composer's buffer. */
-    render(renderer: WebGLRenderer, writeBuffer?: WebGLRenderTarget | null): void;
+    /** Render the scene and resolve TAA into the composer's working-space buffer. */
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget): void;
     dispose(): void;
 }

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

@@ -3,9 +3,10 @@ import { Pass } from 'three/addons/postprocessing/Pass.js';
 /**
  * Temporal reprojection for WebGLRenderer, using depth and camera motion.
  * Object motion is not tracked; no velocity texture is required.
- * Owns scene capture, camera jitter, and history. By default it blends and
- * accumulates in the output color space, like direct canvas rendering, and
- * presents the result without OutputPass.
+ * Owns scene capture, camera jitter, and history. It blends and accumulates
+ * in the output color space, like direct canvas rendering, then hands the
+ * composer a working-space result. Use EffectComposer with OutputPass for
+ * output.
  */
 export declare class TAAPass extends Pass {
     scene: Scene;
@@ -18,20 +19,10 @@ export declare class TAAPass extends Pass {
     maxMotionLength: number;
     /** Increase current-frame weight for subpixel camera motion. */
     useSubpixelCorrection: boolean;
-    /**
-     * Capture and accumulate in the renderer's output color space, ready for
-     * presentation. Set false to stay in the working color space for linear
-     * effects, followed by OutputPass.
-     */
-    accumulateInOutputSpace: boolean;
     private readonly _source;
     private readonly _history;
-    private readonly _size;
     private readonly _clearColor;
     private readonly _state;
-    private _workingColorSpace;
-    private _toneMapping;
-    private _toneMappingExposure;
     private readonly _uniforms;
     private readonly _resolveMaterial;
     private readonly _copyMaterial;
@@ -45,7 +36,7 @@ export declare class TAAPass extends Pass {
     setSize(width: number, height: number): void;
     /** Discard history after a camera cut, scene replacement, or color-space change. */
     reset(): void;
-    /** Render the scene and TAA to the canvas, a target, or the composer's buffer. */
-    render(renderer: WebGLRenderer, writeBuffer?: WebGLRenderTarget | null): void;
+    /** Render the scene and resolve TAA into the composer's working-space buffer. */
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget): void;
     dispose(): void;
 }

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

@@ -0,0 +1,66 @@
+import { GaussianSplatRenderer } from '../rendering/GaussianSplatRenderer.cjs';
+import * as THREE from "three";
+export type SplatCaptureTargetOptions = {
+    width: number;
+    height: number;
+    doubleBuffer?: boolean;
+    superXY?: number;
+} & Omit<THREE.RenderTargetOptions, "stencilBuffer">;
+export interface SplatCaptureOptions {
+    splatRenderer: GaussianSplatRenderer;
+    target?: SplatCaptureTargetOptions;
+}
+export interface SplatCaptureCubeOptions {
+    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;
+};
+/** 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;
+}
+export {};

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

@@ -0,0 +1,66 @@
+import { GaussianSplatRenderer } from '../rendering/GaussianSplatRenderer';
+import * as THREE from "three";
+export type SplatCaptureTargetOptions = {
+    width: number;
+    height: number;
+    doubleBuffer?: boolean;
+    superXY?: number;
+} & Omit<THREE.RenderTargetOptions, "stencilBuffer">;
+export interface SplatCaptureOptions {
+    splatRenderer: GaussianSplatRenderer;
+    target?: SplatCaptureTargetOptions;
+}
+export interface SplatCaptureCubeOptions {
+    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;
+};
+/** 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;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import * 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;
+}

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

@@ -0,0 +1,13 @@
+import * 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;
+}

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

@@ -0,0 +1,17 @@
+import { WebGPURenderer } from 'three/webgpu';
+import * as THREE from "three";
+/** 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;
+}

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

@@ -0,0 +1,17 @@
+import { WebGPURenderer } from 'three/webgpu';
+import * as THREE from "three";
+/** 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;
+}

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

@@ -0,0 +1,5 @@
+import { GaussianSplatCompatibleRenderer } from '../rendering/rendererUtils.cjs';
+import * as THREE from "three";
+/** 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;

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

@@ -0,0 +1,5 @@
+import { GaussianSplatCompatibleRenderer } from '../rendering/rendererUtils';
+import * as THREE from "three";
+/** 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;

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

@@ -0,0 +1,3 @@
+import { 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;

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

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

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,3 @@
+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/index.d.cts

@@ -1,7 +1,7 @@
 export { GaussianSplatRenderer, type GaussianSplatRendererOptions, } from './rendering/GaussianSplatRenderer.cjs';
-export { SplatAccumulator, type SplatMapping, } from './rendering/SplatAccumulator.cjs';
 export { TAAPass } from './addons/TAAPass.cjs';
 export { TAANode } from './addons/TAANode.cjs';
+export { SplatCapture, type SplatCaptureOptions, type SplatCaptureTargetOptions, type SplatCaptureCubeOptions, type SplatCaptureEnvOptions, } from './capture/SplatCapture.cjs';
 export { SplatLoader } from './loaders/SplatLoader.cjs';
 export { RadStreamScheduler, type RadStreamSchedulerOptions, type RadStreamStats, } from './loaders/stream/rad-stream/RadStreamScheduler.cjs';
 export type { SplatFileInput, SplatFileResolver, SplatLoadStage, SplatProgressEvent, } from './loaders/loadTypes.cjs';

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 export { GaussianSplatRenderer, type GaussianSplatRendererOptions, } from './rendering/GaussianSplatRenderer';
-export { SplatAccumulator, type SplatMapping, } from './rendering/SplatAccumulator';
 export { TAAPass } from './addons/TAAPass';
 export { TAANode } from './addons/TAANode';
+export { SplatCapture, type SplatCaptureOptions, type SplatCaptureTargetOptions, type SplatCaptureCubeOptions, type SplatCaptureEnvOptions, } from './capture/SplatCapture';
 export { SplatLoader } from './loaders/SplatLoader';
 export { RadStreamScheduler, type RadStreamSchedulerOptions, type RadStreamStats, } from './loaders/stream/rad-stream/RadStreamScheduler';
 export type { SplatFileInput, SplatFileResolver, SplatLoadStage, SplatProgressEvent, } from './loaders/loadTypes';

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

@@ -23,6 +23,12 @@ export interface GaussianSplatRendererOptions {
      * @default true
      */
     premultipliedAlpha?: boolean;
+    /**
+     * Decode stored sRGB Splat colors to linear before blending. When omitted,
+     * conversion follows the active blend space automatically.
+     * @default undefined
+     */
+    encodeLinear?: boolean;
     /**
      * Pass in a THREE.Timer to synchronize time-based effects across different
      * systems. A supplied timer remains owned and updated by the caller.
@@ -54,15 +60,9 @@ export interface GaussianSplatRendererOptions {
      * @default 1.0
      */
     minPixelRadius?: number;
-    /**
-     * Maximum screen-pixel radius for splat rendering, independent of the
-     * internal projection scale used by focalAdjustment.
-     * @default 256.0
-     */
-    maxPixelRadius?: number;
     /**
      * Minimum alpha value for splat rendering.
-     * @default 0.5 / 255
+     * @default 1 / 255
      */
     minAlpha?: number;
     /**
@@ -161,10 +161,11 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<SplatGeometry, Spl
     readonly uniforms: ReturnType<typeof GaussianSplatRenderer.makeUniforms>;
     autoUpdate: boolean;
     preUpdate: boolean;
+    /** @internal False for a second renderer on the same scene, so each `onFrame` runs once per frame. */
+    frameCallbacks: boolean;
     renderSize: THREE.Vector2;
     maxStdDev: number;
     minPixelRadius: number;
-    maxPixelRadius: number;
     minAlpha: number;
     preBlurAmount: number;
     blurAmount: number;
@@ -183,6 +184,7 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<SplatGeometry, Spl
     private stochasticFrame;
     private _stochasticSort;
     private _premultipliedAlpha;
+    private _encodeLinear;
     private _transparent;
     private readonly sortedBlending;
     private _depthTest;
@@ -253,9 +255,6 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<SplatGeometry, Spl
         minPixelRadius: {
             value: number;
         };
-        maxPixelRadius: {
-            value: number;
-        };
         minAlpha: {
             value: number;
         };
@@ -353,6 +352,9 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<SplatGeometry, Spl
      */
     private getGenerationCamera;
     private driveSort;
+    /** Decode sRGB before blending; undefined follows the active blend space. */
+    get encodeLinear(): boolean | undefined;
+    set encodeLinear(value: boolean | undefined);
     get premultipliedAlpha(): boolean;
     set premultipliedAlpha(value: boolean);
     get transparent(): boolean;

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

@@ -23,6 +23,12 @@ export interface GaussianSplatRendererOptions {
      * @default true
      */
     premultipliedAlpha?: boolean;
+    /**
+     * Decode stored sRGB Splat colors to linear before blending. When omitted,
+     * conversion follows the active blend space automatically.
+     * @default undefined
+     */
+    encodeLinear?: boolean;
     /**
      * Pass in a THREE.Timer to synchronize time-based effects across different
      * systems. A supplied timer remains owned and updated by the caller.
@@ -54,15 +60,9 @@ export interface GaussianSplatRendererOptions {
      * @default 1.0
      */
     minPixelRadius?: number;
-    /**
-     * Maximum screen-pixel radius for splat rendering, independent of the
-     * internal projection scale used by focalAdjustment.
-     * @default 256.0
-     */
-    maxPixelRadius?: number;
     /**
      * Minimum alpha value for splat rendering.
-     * @default 0.5 / 255
+     * @default 1 / 255
      */
     minAlpha?: number;
     /**
@@ -161,10 +161,11 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<SplatGeometry, Spl
     readonly uniforms: ReturnType<typeof GaussianSplatRenderer.makeUniforms>;
     autoUpdate: boolean;
     preUpdate: boolean;
+    /** @internal False for a second renderer on the same scene, so each `onFrame` runs once per frame. */
+    frameCallbacks: boolean;
     renderSize: THREE.Vector2;
     maxStdDev: number;
     minPixelRadius: number;
-    maxPixelRadius: number;
     minAlpha: number;
     preBlurAmount: number;
     blurAmount: number;
@@ -183,6 +184,7 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<SplatGeometry, Spl
     private stochasticFrame;
     private _stochasticSort;
     private _premultipliedAlpha;
+    private _encodeLinear;
     private _transparent;
     private readonly sortedBlending;
     private _depthTest;
@@ -253,9 +255,6 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<SplatGeometry, Spl
         minPixelRadius: {
             value: number;
         };
-        maxPixelRadius: {
-            value: number;
-        };
         minAlpha: {
             value: number;
         };
@@ -353,6 +352,9 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<SplatGeometry, Spl
      */
     private getGenerationCamera;
     private driveSort;
+    /** Decode sRGB before blending; undefined follows the active blend space. */
+    get encodeLinear(): boolean | undefined;
+    set encodeLinear(value: boolean | undefined);
     get premultipliedAlpha(): boolean;
     set premultipliedAlpha(value: boolean);
     get transparent(): boolean;

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

@@ -61,13 +61,14 @@ export declare class SplatAccumulator {
         count: number;
         renderer: GaussianSplatCompatibleRenderer;
     }): void;
-    prepareGenerate({ renderer, scene, timer, camera, layerCamera, previous, }: {
+    prepareGenerate({ renderer, scene, timer, camera, layerCamera, previous, frameCallbacks, }: {
         renderer: GaussianSplatCompatibleRenderer;
         scene: THREE.Scene;
         timer: THREE.Timer;
         camera: THREE.Camera;
         layerCamera?: THREE.Camera;
         previous: SplatAccumulator;
+        frameCallbacks?: boolean;
     }): {
         version: number;
         sortUpdated: boolean;

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

@@ -61,13 +61,14 @@ export declare class SplatAccumulator {
         count: number;
         renderer: GaussianSplatCompatibleRenderer;
     }): void;
-    prepareGenerate({ renderer, scene, timer, camera, layerCamera, previous, }: {
+    prepareGenerate({ renderer, scene, timer, camera, layerCamera, previous, frameCallbacks, }: {
         renderer: GaussianSplatCompatibleRenderer;
         scene: THREE.Scene;
         timer: THREE.Timer;
         camera: THREE.Camera;
         layerCamera?: THREE.Camera;
         previous: SplatAccumulator;
+        frameCallbacks?: boolean;
     }): {
         version: number;
         sortUpdated: boolean;

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

@@ -7,7 +7,7 @@ import { WebGPUSplatBackend } from './webgpu/SplatBackend.cjs';
 import * as THREE from "three";
 export type SplatBackend = WebGLSplatBackend | WebGPUSplatBackend | WebGLFallbackSplatBackend;
 export declare function createSplatBackend(renderer: GaussianSplatCompatibleRenderer, uniforms: Uniforms, options: SplatMaterialOptions): SplatBackend;
-export declare function configureSplatOutput(renderer: GaussianSplatCompatibleRenderer, target: THREE.RenderTarget | null, uniforms: Uniforms): void;
+export declare function configureSplatOutput(renderer: GaussianSplatCompatibleRenderer, target: THREE.RenderTarget | null, uniforms: Uniforms, encodeLinear?: boolean): void;
 export type CPUOrderingUpdate = {
     ordering: Uint32Array;
     activeSplats: number;

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

@@ -7,7 +7,7 @@ import { WebGPUSplatBackend } from './webgpu/SplatBackend';
 import * as THREE from "three";
 export type SplatBackend = WebGLSplatBackend | WebGPUSplatBackend | WebGLFallbackSplatBackend;
 export declare function createSplatBackend(renderer: GaussianSplatCompatibleRenderer, uniforms: Uniforms, options: SplatMaterialOptions): SplatBackend;
-export declare function configureSplatOutput(renderer: GaussianSplatCompatibleRenderer, target: THREE.RenderTarget | null, uniforms: Uniforms): void;
+export declare function configureSplatOutput(renderer: GaussianSplatCompatibleRenderer, target: THREE.RenderTarget | null, uniforms: Uniforms, encodeLinear?: boolean): void;
 export type CPUOrderingUpdate = {
     ordering: Uint32Array;
     activeSplats: number;

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

@@ -2,11 +2,7 @@ import * as THREE from "three";
 type WebGPURenderer = import('three/webgpu').WebGPURenderer;
 export type GaussianSplatCompatibleRenderer = THREE.WebGLRenderer | WebGPURenderer;
 export declare function isWebGPURenderer(renderer: GaussianSplatCompatibleRenderer): renderer is WebGPURenderer;
-export declare function usesNativeWebGPU(renderer: GaussianSplatCompatibleRenderer): renderer is WebGPURenderer & {
-    backend: {
-        isWebGPUBackend: true;
-    };
-};
+export declare function usesNativeWebGPU(renderer: GaussianSplatCompatibleRenderer): boolean;
 /**
  * The eyes of a WebXR camera, or the camera itself. An ArrayCamera without
  * eyes draws as a single view.

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

@@ -2,11 +2,7 @@ import * as THREE from "three";
 type WebGPURenderer = import('three/webgpu').WebGPURenderer;
 export type GaussianSplatCompatibleRenderer = THREE.WebGLRenderer | WebGPURenderer;
 export declare function isWebGPURenderer(renderer: GaussianSplatCompatibleRenderer): renderer is WebGPURenderer;
-export declare function usesNativeWebGPU(renderer: GaussianSplatCompatibleRenderer): renderer is WebGPURenderer & {
-    backend: {
-        isWebGPUBackend: true;
-    };
-};
+export declare function usesNativeWebGPU(renderer: GaussianSplatCompatibleRenderer): boolean;
 /**
  * The eyes of a WebXR camera, or the camera itself. An ArrayCamera without
  * eyes draws as a single view.

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

@@ -37,6 +37,7 @@ type UintWorkgroup = WorkgroupInfoNode & {
     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">;

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

@@ -37,6 +37,7 @@ type UintWorkgroup = WorkgroupInfoNode & {
     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">;

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

@@ -35,9 +35,6 @@ export declare function makeSplatUniforms(): {
     minPixelRadius: {
         value: number;
     };
-    maxPixelRadius: {
-        value: number;
-    };
     minAlpha: {
         value: number;
     };

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

@@ -35,9 +35,6 @@ export declare function makeSplatUniforms(): {
     minPixelRadius: {
         value: number;
     };
-    maxPixelRadius: {
-        value: number;
-    };
     minAlpha: {
         value: number;
     };

package/dist/types/scene/SplatMesh.d.cts

@@ -70,7 +70,7 @@ export declare class SplatMesh extends THREE.Object3D {
     dispose(): void;
     /** Copy cached local bounds; false includes scale/rotation and shape at source alpha 0.01. */
     getBoundingBox(centersOnly?: boolean, target?: THREE.Box3): THREE.Box3;
-    frameUpdate({ time, deltaTime, globalEdits }: SplatMeshFrameContext): void;
+    frameUpdate({ time, deltaTime, globalEdits }: SplatMeshFrameContext, callbacks?: boolean): void;
     updateVersion({ sort }?: {
         sort?: boolean;
     }): void;

package/dist/types/scene/SplatMesh.d.ts

@@ -70,7 +70,7 @@ export declare class SplatMesh extends THREE.Object3D {
     dispose(): void;
     /** Copy cached local bounds; false includes scale/rotation and shape at source alpha 0.01. */
     getBoundingBox(centersOnly?: boolean, target?: THREE.Box3): THREE.Box3;
-    frameUpdate({ time, deltaTime, globalEdits }: SplatMeshFrameContext): void;
+    frameUpdate({ time, deltaTime, globalEdits }: SplatMeshFrameContext, callbacks?: boolean): void;
     updateVersion({ sort }?: {
         sort?: boolean;
     }): void;