gaussian-splat-lite 1.2.0 → 1.2.2

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

@@ -1,7 +1,7 @@
 import { DepthTexture, Matrix4, OrthographicCamera, PerspectiveCamera, Scene } from 'three';
-import { NodeBuilder, NodeFrame, TempNode, TextureNode } from 'three/webgpu';
+import { Node, NodeBuilder, NodeFrame, TextureNode } from 'three/webgpu';
 /** Camera/depth TAA for WebGPURenderer, including its WebGL2 fallback. */
-export declare class TAANode extends TempNode<"vec4"> {
+export declare class TAANode extends Node<"vec4"> {
     scene: Scene;
     camera: PerspectiveCamera | OrthographicCamera;
     static get type(): string;
@@ -11,6 +11,8 @@ export declare class TAANode extends TempNode<"vec4"> {
     useSubpixelCorrection: boolean;
     private readonly source;
     private readonly history;
+    private readonly historyColor;
+    private readonly historyDepth;
     private readonly textureNode;
     private readonly material;
     private readonly quad;

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

@@ -1,7 +1,7 @@
 import { DepthTexture, Matrix4, OrthographicCamera, PerspectiveCamera, Scene } from 'three';
-import { NodeBuilder, NodeFrame, TempNode, TextureNode } from 'three/webgpu';
+import { Node, NodeBuilder, NodeFrame, TextureNode } from 'three/webgpu';
 /** Camera/depth TAA for WebGPURenderer, including its WebGL2 fallback. */
-export declare class TAANode extends TempNode<"vec4"> {
+export declare class TAANode extends Node<"vec4"> {
     scene: Scene;
     camera: PerspectiveCamera | OrthographicCamera;
     static get type(): string;
@@ -11,6 +11,8 @@ export declare class TAANode extends TempNode<"vec4"> {
     useSubpixelCorrection: boolean;
     private readonly source;
     private readonly history;
+    private readonly historyColor;
+    private readonly historyDepth;
     private readonly textureNode;
     private readonly material;
     private readonly quad;

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/addons/taaShared.d.cts

@@ -1,4 +1,4 @@
-import { Camera, Matrix4, OrthographicCamera, PerspectiveCamera, RenderTarget, Vector2, Vector3 } from 'three';
+import { Camera, Matrix4, OrthographicCamera, PerspectiveCamera, RenderTarget, TextureDataType, Vector2, Vector3 } from 'three';
 type TAACamera = PerspectiveCamera | OrthographicCamera;
 type TAAParameters = {
     depthThreshold: number;
@@ -22,7 +22,7 @@ export declare function createTAAState<FloatUniform extends {
     (value: Vector2): Vec2Uniform;
     (value: Vector3): Vec3Uniform;
     (value: Matrix4): Mat4Uniform;
-}, targets: RenderTarget[]): {
+}, targets: RenderTarget[], nodeLogDepth?: boolean): {
     uniforms: {
         renderSize: Vec2Uniform;
         projection: Mat4Uniform;
@@ -34,6 +34,7 @@ export declare function createTAAState<FloatUniform extends {
         reversed: BoolUniform;
         logarithmic: BoolUniform;
         logFar: Vec2Uniform;
+        logNear: Vec2Uniform;
         depthThreshold: FloatUniform;
         edgeDepthDiff: FloatUniform;
         maxMotionLength: FloatUniform;
@@ -44,6 +45,7 @@ export declare function createTAAState<FloatUniform extends {
     jitterIndex: number;
     reset(): void;
     setSize(width: number, height: number): void;
+    setStencil(stencil: boolean, depthType: TextureDataType): void;
     beginCapture(camera: TAACamera): void;
     endCapture(camera: TAACamera): void;
     prepareResolve(camera: TAACamera, parameters: TAAParameters): 0 | 1;

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

@@ -1,4 +1,4 @@
-import { Camera, Matrix4, OrthographicCamera, PerspectiveCamera, RenderTarget, Vector2, Vector3 } from 'three';
+import { Camera, Matrix4, OrthographicCamera, PerspectiveCamera, RenderTarget, TextureDataType, Vector2, Vector3 } from 'three';
 type TAACamera = PerspectiveCamera | OrthographicCamera;
 type TAAParameters = {
     depthThreshold: number;
@@ -22,7 +22,7 @@ export declare function createTAAState<FloatUniform extends {
     (value: Vector2): Vec2Uniform;
     (value: Vector3): Vec3Uniform;
     (value: Matrix4): Mat4Uniform;
-}, targets: RenderTarget[]): {
+}, targets: RenderTarget[], nodeLogDepth?: boolean): {
     uniforms: {
         renderSize: Vec2Uniform;
         projection: Mat4Uniform;
@@ -34,6 +34,7 @@ export declare function createTAAState<FloatUniform extends {
         reversed: BoolUniform;
         logarithmic: BoolUniform;
         logFar: Vec2Uniform;
+        logNear: Vec2Uniform;
         depthThreshold: FloatUniform;
         edgeDepthDiff: FloatUniform;
         maxMotionLength: FloatUniform;
@@ -44,6 +45,7 @@ export declare function createTAAState<FloatUniform extends {
     jitterIndex: number;
     reset(): void;
     setSize(width: number, height: number): void;
+    setStencil(stencil: boolean, depthType: TextureDataType): void;
     beginCapture(camera: TAACamera): void;
     endCapture(camera: TAACamera): void;
     prepareResolve(camera: TAACamera, parameters: TAAParameters): 0 | 1;

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.
@@ -44,7 +50,8 @@ export interface GaussianSplatRendererOptions {
     /**
      * Maximum standard deviations from the center to render Gaussians. Values
      * Math.sqrt(4)..Math.sqrt(9) produce acceptable results and can be tweaked for
-     * performance.
+     * performance. A Gaussian still above minAlpha at this distance fades to
+     * minAlpha there instead of ending in a step.
      * @default Math.sqrt(8)
      */
     maxStdDev?: number;
@@ -54,12 +61,6 @@ 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
@@ -161,10 +162,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 +185,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,12 +256,12 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<SplatGeometry, Spl
         minPixelRadius: {
             value: number;
         };
-        maxPixelRadius: {
-            value: number;
-        };
         minAlpha: {
             value: number;
         };
+        edgeFade: {
+            value: THREE.Vector2;
+        };
         preBlurAmount: {
             value: number;
         };
@@ -353,6 +356,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.
@@ -44,7 +50,8 @@ export interface GaussianSplatRendererOptions {
     /**
      * Maximum standard deviations from the center to render Gaussians. Values
      * Math.sqrt(4)..Math.sqrt(9) produce acceptable results and can be tweaked for
-     * performance.
+     * performance. A Gaussian still above minAlpha at this distance fades to
+     * minAlpha there instead of ending in a step.
      * @default Math.sqrt(8)
      */
     maxStdDev?: number;
@@ -54,12 +61,6 @@ 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
@@ -161,10 +162,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 +185,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,12 +256,12 @@ export declare class GaussianSplatRenderer extends THREE.Mesh<SplatGeometry, Spl
         minPixelRadius: {
             value: number;
         };
-        maxPixelRadius: {
-            value: number;
-        };
         minAlpha: {
             value: number;
         };
+        edgeFade: {
+            value: THREE.Vector2;
+        };
         preBlurAmount: {
             value: number;
         };
@@ -353,6 +356,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;