gaussian-splat-lite 1.2.2 → 1.3.1

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

@@ -1,18 +1,56 @@
-import { Node, TextureNode, UniformNode } from 'three/webgpu';
-import { Uniforms } from '../uniforms';
-import * as THREE from "three";
-export { N } from './tslCompat';
+import type * as THREE from "three";
+import type { Node, TSL, TextureNode, UniformNode } from "three/webgpu";
+import type { Uniforms } from "../uniforms.js";
+export * as N from "three/tsl";
+export type UniformType =
+  | "bool"
+  | "float"
+  | "int"
+  | "uint"
+  | "vec2"
+  | "vec3"
+  | "vec4"
+  | "mat3"
+  | "mat4";
 export declare const E: number;
-export type UniformType = "bool" | "float" | "int" | "uint" | "vec2" | "vec3" | "vec4" | "mat3" | "mat4";
-export declare function uniformBinding<Type extends UniformType>(uniforms: Uniforms, name: string, type: Type): UniformNode<Type, unknown>;
-export declare function textureBinding(uniforms: Uniforms, name: string, array?: boolean): TextureNode<"uvec4">;
-export declare function load2D<T extends TextureNode<unknown>>(binding: T, coord: Node<"ivec2">): T;
-export declare function loadArray<T extends TextureNode<unknown>>(binding: T, coord: Node<"ivec3">): T;
-export declare const splatTexCoord: import('three/src/nodes/TSL.js').FnNode<[Node<"uint">], import('three/webgpu').VarNode<"ivec3", import('three/webgpu').JoinNode<"ivec3">>>;
-export declare const quatVec: import('three/src/nodes/TSL.js').FnNode<[THREE.Vector4 | Node<"vec4">, THREE.Vector3 | Node<"vec3">], Node<"vec3">>;
-export declare const quatQuat: import('three/src/nodes/TSL.js').FnNode<[THREE.Vector4 | Node<"vec4">, THREE.Vector4 | Node<"vec4">], import('three/webgpu').VarNode<"vec4", import('three/webgpu').JoinNode<"vec4">>>;
-export declare const decodeCenter: import('three/src/nodes/TSL.js').FnNode<[Node<"uvec4">], Node<"vec3">>;
-export declare const decodeAlphaShape: import('three/src/nodes/TSL.js').FnNode<[Node<"uvec4">], Node<"vec2">>;
-export declare const decodeRgba: import('three/src/nodes/TSL.js').FnNode<[Node<"uvec4">, number | Node<"uint"> | Node<"float">], import('three/webgpu').VarNode<"vec4", import('three/webgpu').JoinNode<"vec4">>>;
-export declare const decodeLnScales: import('three/src/nodes/TSL.js').FnNode<[Node<"uvec4">], import('three/webgpu').VarNode<"vec3", import('three/webgpu').JoinNode<"vec3">>>;
-export declare const decodeQuaternion: import('three/src/nodes/TSL.js').FnNode<[Node<"uint">], import('three/webgpu').VarNode<"vec4", import('three/webgpu').JoinNode<"vec4">>>;
+/** Texture loads without a sampler, preserving the texture's integer format. */
+export declare function uintTexture(
+  texture: THREE.Texture,
+): TextureNode<"uvec4">;
+export declare function uniformBinding<Type extends UniformType>(
+  uniforms: Uniforms,
+  name: string,
+  type: Type,
+): UniformNode<Type, unknown>;
+export declare function textureBinding(
+  uniforms: Uniforms,
+  name: string,
+): TextureNode<"uvec4">;
+export declare function load2D<T extends TextureNode<unknown>>(
+  binding: T,
+  coord: Node<"ivec2">,
+): T;
+export declare function loadArray<T extends TextureNode<unknown>>(
+  binding: T,
+  coord: Node<"ivec3">,
+): T;
+export declare const splatTexCoord: TSL.FnNode<[Node<"uint">], Node<"ivec3">>;
+export declare const quatVec: TSL.FnNode<
+  [Node<"vec4"> | THREE.Vector4, THREE.Vector3 | Node<"vec3">],
+  Node<"vec3">
+>;
+export declare const quatQuat: TSL.FnNode<
+  [Node<"vec4"> | THREE.Vector4, Node<"vec4"> | THREE.Vector4],
+  Node<"vec4">
+>;
+export declare const decodeCenter: TSL.FnNode<[Node<"uvec4">], Node<"vec3">>;
+export declare const decodeAlphaShape: TSL.FnNode<
+  [Node<"uvec4">],
+  Node<"vec2">
+>;
+export declare const decodeRgba: TSL.FnNode<
+  [Node<"uvec4">, number | Node<"uint"> | Node<"float">],
+  Node<"vec4">
+>;
+export declare const decodeLnScales: TSL.FnNode<[Node<"uvec4">], Node<"vec3">>;
+export declare const decodeQuaternion: TSL.FnNode<[Node<"uint">], Node<"vec4">>;

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

@@ -0,0 +1,7 @@
+import type { Node } from "three/webgpu";
+
+/** Matches the four stratified coverage decisions in splatFragment.glsl. */
+export declare function stochasticCoverage(
+  alpha: Node<"float">,
+  random: Node<"float">,
+): void;

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

@@ -0,0 +1,7 @@
+import type { Node } from "three/webgpu";
+
+/** Matches the four stratified coverage decisions in splatFragment.glsl. */
+export declare function stochasticCoverage(
+  alpha: Node<"float">,
+  random: Node<"float">,
+): void;

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

@@ -1,14 +1,24 @@
-import { Node } from 'three/webgpu';
-import { Uniforms } from '../uniforms.cjs';
-import { ProjectionView } from './ProjectionProgram.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { Node } from "three/webgpu";
+import type { Uniforms } from "../uniforms.cjs";
+import type { ProjectionView } from "./ProjectionProgram.cjs";
 /** Eye of the current WebXR draw; multiview draws both eyes at once. */
 export declare function viewIndex(camera: THREE.Camera): Node<"uint">;
+/** A per-layout projection array also supports changing WebXR eye counts. */
+export declare function splatProjectionMatrix(
+  camera: THREE.Camera,
+): Node<"mat4">;
 /** Viewport data for drawing splats that have already been projected. */
-export declare function splatViewportUniforms(uniforms: Uniforms, camera: THREE.Camera): {
-    renderSize: Node<"vec2">;
-    viewportOrigin: Node<"vec2">;
+export declare function splatViewportUniforms(
+  uniforms: Uniforms,
+  camera: THREE.Camera,
+): {
+  renderSize: Node<"vec2">;
+  viewportOrigin: Node<"vec2">;
 };
-export declare function splatViewUniforms(uniforms: Uniforms, camera: THREE.Camera): Omit<ProjectionView, "projectionMatrix"> & {
-    viewportOrigin: Node<"vec2">;
+export declare function splatViewUniforms(
+  uniforms: Uniforms,
+  camera: THREE.Camera,
+): ProjectionView & {
+  viewportOrigin: Node<"vec2">;
 };

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

@@ -1,14 +1,24 @@
-import { Node } from 'three/webgpu';
-import { Uniforms } from '../uniforms';
-import { ProjectionView } from './ProjectionProgram';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { Node } from "three/webgpu";
+import type { Uniforms } from "../uniforms.js";
+import type { ProjectionView } from "./ProjectionProgram.js";
 /** Eye of the current WebXR draw; multiview draws both eyes at once. */
 export declare function viewIndex(camera: THREE.Camera): Node<"uint">;
+/** A per-layout projection array also supports changing WebXR eye counts. */
+export declare function splatProjectionMatrix(
+  camera: THREE.Camera,
+): Node<"mat4">;
 /** Viewport data for drawing splats that have already been projected. */
-export declare function splatViewportUniforms(uniforms: Uniforms, camera: THREE.Camera): {
-    renderSize: Node<"vec2">;
-    viewportOrigin: Node<"vec2">;
+export declare function splatViewportUniforms(
+  uniforms: Uniforms,
+  camera: THREE.Camera,
+): {
+  renderSize: Node<"vec2">;
+  viewportOrigin: Node<"vec2">;
 };
-export declare function splatViewUniforms(uniforms: Uniforms, camera: THREE.Camera): Omit<ProjectionView, "projectionMatrix"> & {
-    viewportOrigin: Node<"vec2">;
+export declare function splatViewUniforms(
+  uniforms: Uniforms,
+  camera: THREE.Camera,
+): ProjectionView & {
+  viewportOrigin: Node<"vec2">;
 };

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

@@ -1,91 +1,91 @@
-import * as THREE from "three";
+import type * as THREE from "three";
 export type Uniforms = Record<string, THREE.IUniform>;
 export declare const ORDERING_TEXTURE_WIDTH = 4096;
 export declare const SPLATS_PER_ORDERING_ROW: number;
 export declare const emptyOrdering: THREE.DataTexture;
 export declare const DEFAULT_MIN_ALPHA: number;
 export declare function makeSplatUniforms(): {
-    renderSize: {
-        value: THREE.Vector2;
-    };
-    viewportOrigin: {
-        value: THREE.Vector2;
-    };
-    renderOrigin: {
-        value: THREE.Vector3;
-    };
-    near: {
-        value: number;
-    };
-    far: {
-        value: number;
-    };
-    renderToViewQuat: {
-        value: THREE.Quaternion;
-    };
-    renderToViewPos: {
-        value: THREE.Vector3;
-    };
-    renderToViewScale: {
-        value: number;
-    };
-    maxStdDev: {
-        value: number;
-    };
-    minPixelRadius: {
-        value: number;
-    };
-    minAlpha: {
-        value: number;
-    };
-    edgeFade: {
-        value: THREE.Vector2;
-    };
-    preBlurAmount: {
-        value: number;
-    };
-    blurAmount: {
-        value: number;
-    };
-    clipXY: {
-        value: number;
-    };
-    focalAdjustment: {
-        value: number;
-    };
-    encodeLinear: {
-        value: boolean;
-    };
-    splatCount: {
-        value: number;
-    };
-    ordering: {
-        type: string;
-        value: THREE.DataTexture;
-    };
-    splats: {
-        type: string;
-        value: THREE.Texture<unknown, THREE.TextureEventMap>;
-    };
-    splats2: {
-        type: string;
-        value: THREE.Texture<unknown, THREE.TextureEventMap>;
-    };
-    stochasticSeeds: {
-        type: string;
-        value: THREE.Texture<unknown, THREE.TextureEventMap>;
-    };
-    stochasticNoise: {
-        value: THREE.DataTexture;
-    };
-    stochasticSample: {
-        value: number;
-    };
-    stochastic: {
-        value: boolean;
-    };
-    stochasticOrdering: {
-        value: boolean;
-    };
+  renderSize: {
+    value: THREE.Vector2;
+  };
+  viewportOrigin: {
+    value: THREE.Vector2;
+  };
+  renderOrigin: {
+    value: THREE.Vector3;
+  };
+  near: {
+    value: number;
+  };
+  far: {
+    value: number;
+  };
+  renderToViewQuat: {
+    value: THREE.Quaternion;
+  };
+  renderToViewPos: {
+    value: THREE.Vector3;
+  };
+  renderToViewScale: {
+    value: number;
+  };
+  maxStdDev: {
+    value: number;
+  };
+  minPixelRadius: {
+    value: number;
+  };
+  minAlpha: {
+    value: number;
+  };
+  edgeFade: {
+    value: THREE.Vector2;
+  };
+  preBlurAmount: {
+    value: number;
+  };
+  blurAmount: {
+    value: number;
+  };
+  clipXY: {
+    value: number;
+  };
+  focalAdjustment: {
+    value: number;
+  };
+  encodeLinear: {
+    value: boolean;
+  };
+  splatCount: {
+    value: number;
+  };
+  ordering: {
+    type: string;
+    value: THREE.DataTexture;
+  };
+  splats: {
+    type: string;
+    value: THREE.Texture<unknown, THREE.TextureEventMap>;
+  };
+  splats2: {
+    type: string;
+    value: THREE.Texture<unknown, THREE.TextureEventMap>;
+  };
+  stochasticSeeds: {
+    type: string;
+    value: THREE.Texture<unknown, THREE.TextureEventMap>;
+  };
+  stochasticNoise: {
+    value: THREE.DataTexture;
+  };
+  stochasticSample: {
+    value: number;
+  };
+  stochastic: {
+    value: boolean;
+  };
+  stochasticOrdering: {
+    value: boolean;
+  };
 };
 export declare function makeGenerateUniforms(): Uniforms;

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

@@ -1,91 +1,91 @@
-import * as THREE from "three";
+import type * as THREE from "three";
 export type Uniforms = Record<string, THREE.IUniform>;
 export declare const ORDERING_TEXTURE_WIDTH = 4096;
 export declare const SPLATS_PER_ORDERING_ROW: number;
 export declare const emptyOrdering: THREE.DataTexture;
 export declare const DEFAULT_MIN_ALPHA: number;
 export declare function makeSplatUniforms(): {
-    renderSize: {
-        value: THREE.Vector2;
-    };
-    viewportOrigin: {
-        value: THREE.Vector2;
-    };
-    renderOrigin: {
-        value: THREE.Vector3;
-    };
-    near: {
-        value: number;
-    };
-    far: {
-        value: number;
-    };
-    renderToViewQuat: {
-        value: THREE.Quaternion;
-    };
-    renderToViewPos: {
-        value: THREE.Vector3;
-    };
-    renderToViewScale: {
-        value: number;
-    };
-    maxStdDev: {
-        value: number;
-    };
-    minPixelRadius: {
-        value: number;
-    };
-    minAlpha: {
-        value: number;
-    };
-    edgeFade: {
-        value: THREE.Vector2;
-    };
-    preBlurAmount: {
-        value: number;
-    };
-    blurAmount: {
-        value: number;
-    };
-    clipXY: {
-        value: number;
-    };
-    focalAdjustment: {
-        value: number;
-    };
-    encodeLinear: {
-        value: boolean;
-    };
-    splatCount: {
-        value: number;
-    };
-    ordering: {
-        type: string;
-        value: THREE.DataTexture;
-    };
-    splats: {
-        type: string;
-        value: THREE.Texture<unknown, THREE.TextureEventMap>;
-    };
-    splats2: {
-        type: string;
-        value: THREE.Texture<unknown, THREE.TextureEventMap>;
-    };
-    stochasticSeeds: {
-        type: string;
-        value: THREE.Texture<unknown, THREE.TextureEventMap>;
-    };
-    stochasticNoise: {
-        value: THREE.DataTexture;
-    };
-    stochasticSample: {
-        value: number;
-    };
-    stochastic: {
-        value: boolean;
-    };
-    stochasticOrdering: {
-        value: boolean;
-    };
+  renderSize: {
+    value: THREE.Vector2;
+  };
+  viewportOrigin: {
+    value: THREE.Vector2;
+  };
+  renderOrigin: {
+    value: THREE.Vector3;
+  };
+  near: {
+    value: number;
+  };
+  far: {
+    value: number;
+  };
+  renderToViewQuat: {
+    value: THREE.Quaternion;
+  };
+  renderToViewPos: {
+    value: THREE.Vector3;
+  };
+  renderToViewScale: {
+    value: number;
+  };
+  maxStdDev: {
+    value: number;
+  };
+  minPixelRadius: {
+    value: number;
+  };
+  minAlpha: {
+    value: number;
+  };
+  edgeFade: {
+    value: THREE.Vector2;
+  };
+  preBlurAmount: {
+    value: number;
+  };
+  blurAmount: {
+    value: number;
+  };
+  clipXY: {
+    value: number;
+  };
+  focalAdjustment: {
+    value: number;
+  };
+  encodeLinear: {
+    value: boolean;
+  };
+  splatCount: {
+    value: number;
+  };
+  ordering: {
+    type: string;
+    value: THREE.DataTexture;
+  };
+  splats: {
+    type: string;
+    value: THREE.Texture<unknown, THREE.TextureEventMap>;
+  };
+  splats2: {
+    type: string;
+    value: THREE.Texture<unknown, THREE.TextureEventMap>;
+  };
+  stochasticSeeds: {
+    type: string;
+    value: THREE.Texture<unknown, THREE.TextureEventMap>;
+  };
+  stochasticNoise: {
+    value: THREE.DataTexture;
+  };
+  stochasticSample: {
+    value: number;
+  };
+  stochastic: {
+    value: boolean;
+  };
+  stochasticOrdering: {
+    value: boolean;
+  };
 };
 export declare function makeGenerateUniforms(): Uniforms;

package/dist/types/rendering/webgl/AccumulatorGenerator.d.cts

@@ -1,17 +1,33 @@
-import { GaussianSplatCompatibleRenderer } from '../rendererUtils.cjs';
-import { Uniforms } from '../uniforms.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { GaussianSplatCompatibleRenderer } from "../rendererUtils.cjs";
+import type { Uniforms } from "../uniforms.cjs";
 /** Sorted rendering needs no seed layer; stochastic draws read one per Splat. */
-export declare function createWebGLAccumulatorTarget(width: number, height: number, depth: number, stochasticSeeds: boolean): THREE.WebGLArrayRenderTarget;
+export declare function createWebGLAccumulatorTarget(
+  width: number,
+  height: number,
+  depth: number,
+  stochasticSeeds: boolean,
+): THREE.WebGLArrayRenderTarget;
 /** Whether an accumulator target stores stochastic sampling seeds. */
-export declare function hasStochasticSeeds(target: THREE.WebGLArrayRenderTarget): boolean;
+export declare function hasStochasticSeeds(
+  target: THREE.WebGLArrayRenderTarget,
+): boolean;
 export declare function getWebGLGenerateUniforms(): Uniforms;
-export declare function generateWebGLAccumulator(options: AccumulatorRenderOptions<THREE.WebGLRenderer>): void;
-export type AccumulatorRenderOptions<Renderer extends GaussianSplatCompatibleRenderer = GaussianSplatCompatibleRenderer> = {
-    renderer: Renderer;
-    target: THREE.WebGLArrayRenderTarget;
-    base: number;
-    count: number;
+export declare function generateWebGLAccumulator(
+  options: AccumulatorRenderOptions<THREE.WebGLRenderer>,
+): void;
+export type AccumulatorRenderOptions<
+  Renderer extends
+    GaussianSplatCompatibleRenderer = GaussianSplatCompatibleRenderer,
+> = {
+  renderer: Renderer;
+  target: THREE.WebGLArrayRenderTarget;
+  base: number;
+  count: number;
 };
 /** Draw row-aligned ranges into array layers with either WebGL renderer API. */
-export declare function renderAccumulatorLayers({ renderer, target, base, count }: AccumulatorRenderOptions, uniforms: Uniforms, draw: () => void): void;
+export declare function renderAccumulatorLayers(
+  { renderer, target, base, count }: AccumulatorRenderOptions,
+  uniforms: Uniforms,
+  draw: () => void,
+): void;

package/dist/types/rendering/webgl/AccumulatorGenerator.d.ts

@@ -1,17 +1,33 @@
-import { GaussianSplatCompatibleRenderer } from '../rendererUtils';
-import { Uniforms } from '../uniforms';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { GaussianSplatCompatibleRenderer } from "../rendererUtils.js";
+import type { Uniforms } from "../uniforms.js";
 /** Sorted rendering needs no seed layer; stochastic draws read one per Splat. */
-export declare function createWebGLAccumulatorTarget(width: number, height: number, depth: number, stochasticSeeds: boolean): THREE.WebGLArrayRenderTarget;
+export declare function createWebGLAccumulatorTarget(
+  width: number,
+  height: number,
+  depth: number,
+  stochasticSeeds: boolean,
+): THREE.WebGLArrayRenderTarget;
 /** Whether an accumulator target stores stochastic sampling seeds. */
-export declare function hasStochasticSeeds(target: THREE.WebGLArrayRenderTarget): boolean;
+export declare function hasStochasticSeeds(
+  target: THREE.WebGLArrayRenderTarget,
+): boolean;
 export declare function getWebGLGenerateUniforms(): Uniforms;
-export declare function generateWebGLAccumulator(options: AccumulatorRenderOptions<THREE.WebGLRenderer>): void;
-export type AccumulatorRenderOptions<Renderer extends GaussianSplatCompatibleRenderer = GaussianSplatCompatibleRenderer> = {
-    renderer: Renderer;
-    target: THREE.WebGLArrayRenderTarget;
-    base: number;
-    count: number;
+export declare function generateWebGLAccumulator(
+  options: AccumulatorRenderOptions<THREE.WebGLRenderer>,
+): void;
+export type AccumulatorRenderOptions<
+  Renderer extends
+    GaussianSplatCompatibleRenderer = GaussianSplatCompatibleRenderer,
+> = {
+  renderer: Renderer;
+  target: THREE.WebGLArrayRenderTarget;
+  base: number;
+  count: number;
 };
 /** Draw row-aligned ranges into array layers with either WebGL renderer API. */
-export declare function renderAccumulatorLayers({ renderer, target, base, count }: AccumulatorRenderOptions, uniforms: Uniforms, draw: () => void): void;
+export declare function renderAccumulatorLayers(
+  { renderer, target, base, count }: AccumulatorRenderOptions,
+  uniforms: Uniforms,
+  draw: () => void,
+): void;

package/dist/types/rendering/webgl/OrderingTexture.d.cts

@@ -1,10 +1,13 @@
-import { CPUOrderingUpdate } from '../backend.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { CPUOrderingUpdate } from "../backend.cjs";
 /** CPU ordering storage shared by both WebGL backends; uploads stay backend-specific. */
 export declare class OrderingTexture {
-    texture: THREE.DataTexture | null;
-    getCapacity(count: number): number;
-    get data(): Uint32Array | null;
-    update({ ordering, activeSplats, requiredCapacity, shrink }: CPUOrderingUpdate, uploadRows: (texture: THREE.DataTexture, rows: number) => void): THREE.DataTexture;
-    dispose(): void;
+  texture: THREE.DataTexture | null;
+  getCapacity(count: number): number;
+  get data(): Uint32Array | null;
+  update(
+    { ordering, activeSplats, requiredCapacity, shrink }: CPUOrderingUpdate,
+    uploadRows: (texture: THREE.DataTexture, rows: number) => void,
+  ): THREE.DataTexture;
+  dispose(): void;
 }

package/dist/types/rendering/webgl/OrderingTexture.d.ts

@@ -1,10 +1,13 @@
-import { CPUOrderingUpdate } from '../backend';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { CPUOrderingUpdate } from "../backend.js";
 /** CPU ordering storage shared by both WebGL backends; uploads stay backend-specific. */
 export declare class OrderingTexture {
-    texture: THREE.DataTexture | null;
-    getCapacity(count: number): number;
-    get data(): Uint32Array | null;
-    update({ ordering, activeSplats, requiredCapacity, shrink }: CPUOrderingUpdate, uploadRows: (texture: THREE.DataTexture, rows: number) => void): THREE.DataTexture;
-    dispose(): void;
+  texture: THREE.DataTexture | null;
+  getCapacity(count: number): number;
+  get data(): Uint32Array | null;
+  update(
+    { ordering, activeSplats, requiredCapacity, shrink }: CPUOrderingUpdate,
+    uploadRows: (texture: THREE.DataTexture, rows: number) => void,
+  ): THREE.DataTexture;
+  dispose(): void;
 }