gaussian-splat-lite 1.2.2 → 1.3.0

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

@@ -1,8 +1,14 @@
-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): boolean;
+import type * 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,
+): boolean;
 /**
  * The eyes of a WebXR camera, or the camera itself. An ArrayCamera without
  * eyes draws as a single view.
@@ -13,9 +19,18 @@ export declare function getViews(camera: THREE.Camera): THREE.Camera[];
  * or for WebXR eyes the shared head. Reads world matrices as Three composed
  * them with any camera rig.
  */
-export declare function getMeanViewPose(views: readonly THREE.Camera[], position: THREE.Vector3, direction: THREE.Vector3): void;
-export declare function getRenderFrame(renderer: GaussianSplatCompatibleRenderer): number;
-export declare function isXRRenderTarget(renderTarget: THREE.RenderTarget | null): boolean;
-export declare function assertSupportedRenderer(renderer: GaussianSplatCompatibleRenderer): void;
-export declare function setRendererRenderTarget(renderer: GaussianSplatCompatibleRenderer, target: THREE.RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void;
+export declare function getMeanViewPose(
+  views: readonly THREE.Camera[],
+  position: THREE.Vector3,
+  direction: THREE.Vector3,
+): void;
+export declare function getRenderFrame(
+  renderer: GaussianSplatCompatibleRenderer,
+): number;
+export declare function isXRRenderTarget(
+  renderTarget: THREE.RenderTarget | null,
+): boolean;
+export declare function assertSupportedRenderer(
+  renderer: GaussianSplatCompatibleRenderer,
+): void;
 export {};

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

@@ -1,8 +1,14 @@
-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): boolean;
+import type * 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,
+): boolean;
 /**
  * The eyes of a WebXR camera, or the camera itself. An ArrayCamera without
  * eyes draws as a single view.
@@ -13,9 +19,18 @@ export declare function getViews(camera: THREE.Camera): THREE.Camera[];
  * or for WebXR eyes the shared head. Reads world matrices as Three composed
  * them with any camera rig.
  */
-export declare function getMeanViewPose(views: readonly THREE.Camera[], position: THREE.Vector3, direction: THREE.Vector3): void;
-export declare function getRenderFrame(renderer: GaussianSplatCompatibleRenderer): number;
-export declare function isXRRenderTarget(renderTarget: THREE.RenderTarget | null): boolean;
-export declare function assertSupportedRenderer(renderer: GaussianSplatCompatibleRenderer): void;
-export declare function setRendererRenderTarget(renderer: GaussianSplatCompatibleRenderer, target: THREE.RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void;
+export declare function getMeanViewPose(
+  views: readonly THREE.Camera[],
+  position: THREE.Vector3,
+  direction: THREE.Vector3,
+): void;
+export declare function getRenderFrame(
+  renderer: GaussianSplatCompatibleRenderer,
+): number;
+export declare function isXRRenderTarget(
+  renderTarget: THREE.RenderTarget | null,
+): boolean;
+export declare function assertSupportedRenderer(
+  renderer: GaussianSplatCompatibleRenderer,
+): void;
 export {};

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

@@ -1,20 +1,22 @@
-import { Node } from 'three/webgpu';
-import { Uniforms } from '../uniforms.cjs';
-export declare function createGenerateProgram({ uniforms }: {
-    uniforms: Uniforms;
+import type { Node } from "three/webgpu";
+import type { Uniforms } from "../uniforms.cjs";
+export declare function createGenerateProgram({
+  uniforms,
+}: {
+  uniforms: Uniforms;
 }): ((index: Node<"uint">) => {
-    accumulatorA: import('three/webgpu').VarNode<"uvec4", import('three/webgpu').VarNode<"uvec4", import('three/webgpu').ConstNode<"uvec4", import('three').Vector4>>>;
-    accumulatorB: import('three/webgpu').VarNode<"uvec4", import('three/webgpu').VarNode<"uvec4", import('three/webgpu').ConstNode<"uvec4", import('three').Vector4>>>;
-    stochasticSeed: import('three/webgpu').VarNode<"uint", import('three/webgpu').VarNode<"uint", import('three/webgpu').ConstNode<"uint", number>>>;
+  accumulatorA: Node<"uvec4">;
+  accumulatorB: Node<"uvec4">;
+  stochasticSeed: Node<"uint">;
 }) & {
-    prepare: (index: Node<"uint">) => {
-        resolveRgb: () => Node<"vec3">;
-        valid: import('three/webgpu').VarNode<"bool", import('three/webgpu').VarNode<"bool", import('three/webgpu').ConstNode<"bool", boolean>>>;
-        center: import('three/webgpu').VarNode<"vec3", import('three/webgpu').VarNode<"vec3", import('three/webgpu').ConstNode<"vec3", import('three').Vector3>>>;
-        lnScales: import('three/webgpu').VarNode<"vec3", import('three/webgpu').VarNode<"vec3", import('three/webgpu').ConstNode<"vec3", import('three').Vector3>>>;
-        quaternion: import('three/webgpu').VarNode<"vec4", import('three/webgpu').VarNode<"vec4", import('three/webgpu').ConstNode<"vec4", import('three').Vector4>>>;
-        rgba: import('three/webgpu').VarNode<"vec4", import('three/webgpu').VarNode<"vec4", import('three/webgpu').ConstNode<"vec4", import('three').Vector4>>>;
-        shapeAmount: import('three/webgpu').VarNode<"float", import('three/webgpu').VarNode<"float", import('three/webgpu').ConstNode<"float", number>>>;
-        stochasticSeed: import('three/webgpu').VarNode<"uint", import('three/webgpu').VarNode<"uint", import('three/webgpu').ConstNode<"uint", number>>>;
-    };
+  prepare: (index: Node<"uint">) => {
+    resolveRgb: () => Node<"vec3">;
+    valid: Node<"bool">;
+    center: Node<"vec3">;
+    lnScales: Node<"vec3">;
+    quaternion: Node<"vec4">;
+    rgba: Node<"vec4">;
+    shapeAmount: Node<"float">;
+    stochasticSeed: Node<"uint">;
+  };
 };

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

@@ -1,20 +1,22 @@
-import { Node } from 'three/webgpu';
-import { Uniforms } from '../uniforms';
-export declare function createGenerateProgram({ uniforms }: {
-    uniforms: Uniforms;
+import type { Node } from "three/webgpu";
+import type { Uniforms } from "../uniforms.js";
+export declare function createGenerateProgram({
+  uniforms,
+}: {
+  uniforms: Uniforms;
 }): ((index: Node<"uint">) => {
-    accumulatorA: import('three/webgpu').VarNode<"uvec4", import('three/webgpu').VarNode<"uvec4", import('three/webgpu').ConstNode<"uvec4", import('three').Vector4>>>;
-    accumulatorB: import('three/webgpu').VarNode<"uvec4", import('three/webgpu').VarNode<"uvec4", import('three/webgpu').ConstNode<"uvec4", import('three').Vector4>>>;
-    stochasticSeed: import('three/webgpu').VarNode<"uint", import('three/webgpu').VarNode<"uint", import('three/webgpu').ConstNode<"uint", number>>>;
+  accumulatorA: Node<"uvec4">;
+  accumulatorB: Node<"uvec4">;
+  stochasticSeed: Node<"uint">;
 }) & {
-    prepare: (index: Node<"uint">) => {
-        resolveRgb: () => Node<"vec3">;
-        valid: import('three/webgpu').VarNode<"bool", import('three/webgpu').VarNode<"bool", import('three/webgpu').ConstNode<"bool", boolean>>>;
-        center: import('three/webgpu').VarNode<"vec3", import('three/webgpu').VarNode<"vec3", import('three/webgpu').ConstNode<"vec3", import('three').Vector3>>>;
-        lnScales: import('three/webgpu').VarNode<"vec3", import('three/webgpu').VarNode<"vec3", import('three/webgpu').ConstNode<"vec3", import('three').Vector3>>>;
-        quaternion: import('three/webgpu').VarNode<"vec4", import('three/webgpu').VarNode<"vec4", import('three/webgpu').ConstNode<"vec4", import('three').Vector4>>>;
-        rgba: import('three/webgpu').VarNode<"vec4", import('three/webgpu').VarNode<"vec4", import('three/webgpu').ConstNode<"vec4", import('three').Vector4>>>;
-        shapeAmount: import('three/webgpu').VarNode<"float", import('three/webgpu').VarNode<"float", import('three/webgpu').ConstNode<"float", number>>>;
-        stochasticSeed: import('three/webgpu').VarNode<"uint", import('three/webgpu').VarNode<"uint", import('three/webgpu').ConstNode<"uint", number>>>;
-    };
+  prepare: (index: Node<"uint">) => {
+    resolveRgb: () => Node<"vec3">;
+    valid: Node<"bool">;
+    center: Node<"vec3">;
+    lnScales: Node<"vec3">;
+    quaternion: Node<"vec4">;
+    rgba: Node<"vec4">;
+    shapeAmount: Node<"float">;
+    stochasticSeed: Node<"uint">;
+  };
 };

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

@@ -1,39 +1,44 @@
-import { Node } from 'three/webgpu';
-import { Uniforms } from '../uniforms.cjs';
+import type { Node } from "three/webgpu";
+import type { Uniforms } from "../uniforms.cjs";
 export type ProjectionView = {
-    projectionMatrix: Node<"mat4">;
-    renderToViewQuat: Node<"vec4">;
-    renderToViewPos: Node<"vec3">;
-    renderToViewScale: Node<"float">;
-    near: Node<"float">;
-    far: Node<"float">;
-    renderSize: Node<"vec2">;
-};
-type ProjectionInput = {
-    first: Node<"uvec4">;
-    second: Node<"uvec4">;
-} | {
-    valid: Node<"bool">;
-    center: Node<"vec3">;
-    lnScales: Node<"vec3">;
-    quaternion: Node<"vec4">;
-    rgba: Node<"vec4">;
-    shapeAmount: Node<"float">;
+  projectionMatrix: Node<"mat4">;
+  renderToViewQuat: Node<"vec4">;
+  renderToViewPos: Node<"vec3">;
+  renderToViewScale: Node<"float">;
+  near: Node<"float">;
+  far: Node<"float">;
+  renderSize: Node<"vec2">;
 };
+type ProjectionInput =
+  | {
+      first: Node<"uvec4">;
+      second: Node<"uvec4">;
+    }
+  | {
+      valid: Node<"bool">;
+      center: Node<"vec3">;
+      lnScales: Node<"vec3">;
+      quaternion: Node<"vec4">;
+      rgba: Node<"vec4">;
+      shapeAmount: Node<"float">;
+    };
 export type SplatProjection = {
-    valid: Node<"bool">;
-    clipCenter: Node<"vec4">;
-    viewDepth: Node<"float">;
-    /** NDC offsets for each +/-1 quad corner. */
-    axis1: Node<"vec2">;
-    axis2: Node<"vec2">;
-    /** Source color space; the draw stage applies encodeLinear. */
-    rgba: Node<"vec4">;
-    supportRadius: Node<"float">;
-    /** A wide kernel's low 16 bits hold its edge fade as a half. */
-    supportRadiusSquared: Node<"float">;
-    kernelPower: Node<"float">;
+  valid: Node<"bool">;
+  clipCenter: Node<"vec4">;
+  viewDepth: Node<"float">;
+  /** NDC offsets for each +/-1 quad corner. */
+  axis1: Node<"vec2">;
+  axis2: Node<"vec2">;
+  /** Source color space; the draw stage applies encodeLinear. */
+  rgba: Node<"vec4">;
+  supportRadius: Node<"float">;
+  /** A wide kernel's low 16 bits hold its edge fade as a half. */
+  supportRadiusSquared: Node<"float">;
+  kernelPower: Node<"float">;
 };
 /** Shared projection for vertex and compute paths. Call inside a TSL Fn. */
-export declare function createProjectionProgram(uniforms: Uniforms, view: ProjectionView): (source: ProjectionInput, includeColor?: boolean) => SplatProjection;
+export declare function createProjectionProgram(
+  uniforms: Uniforms,
+  view: ProjectionView,
+): (source: ProjectionInput, includeColor?: boolean) => SplatProjection;
 export {};

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

@@ -1,39 +1,44 @@
-import { Node } from 'three/webgpu';
-import { Uniforms } from '../uniforms';
+import type { Node } from "three/webgpu";
+import type { Uniforms } from "../uniforms.js";
 export type ProjectionView = {
-    projectionMatrix: Node<"mat4">;
-    renderToViewQuat: Node<"vec4">;
-    renderToViewPos: Node<"vec3">;
-    renderToViewScale: Node<"float">;
-    near: Node<"float">;
-    far: Node<"float">;
-    renderSize: Node<"vec2">;
-};
-type ProjectionInput = {
-    first: Node<"uvec4">;
-    second: Node<"uvec4">;
-} | {
-    valid: Node<"bool">;
-    center: Node<"vec3">;
-    lnScales: Node<"vec3">;
-    quaternion: Node<"vec4">;
-    rgba: Node<"vec4">;
-    shapeAmount: Node<"float">;
+  projectionMatrix: Node<"mat4">;
+  renderToViewQuat: Node<"vec4">;
+  renderToViewPos: Node<"vec3">;
+  renderToViewScale: Node<"float">;
+  near: Node<"float">;
+  far: Node<"float">;
+  renderSize: Node<"vec2">;
 };
+type ProjectionInput =
+  | {
+      first: Node<"uvec4">;
+      second: Node<"uvec4">;
+    }
+  | {
+      valid: Node<"bool">;
+      center: Node<"vec3">;
+      lnScales: Node<"vec3">;
+      quaternion: Node<"vec4">;
+      rgba: Node<"vec4">;
+      shapeAmount: Node<"float">;
+    };
 export type SplatProjection = {
-    valid: Node<"bool">;
-    clipCenter: Node<"vec4">;
-    viewDepth: Node<"float">;
-    /** NDC offsets for each +/-1 quad corner. */
-    axis1: Node<"vec2">;
-    axis2: Node<"vec2">;
-    /** Source color space; the draw stage applies encodeLinear. */
-    rgba: Node<"vec4">;
-    supportRadius: Node<"float">;
-    /** A wide kernel's low 16 bits hold its edge fade as a half. */
-    supportRadiusSquared: Node<"float">;
-    kernelPower: Node<"float">;
+  valid: Node<"bool">;
+  clipCenter: Node<"vec4">;
+  viewDepth: Node<"float">;
+  /** NDC offsets for each +/-1 quad corner. */
+  axis1: Node<"vec2">;
+  axis2: Node<"vec2">;
+  /** Source color space; the draw stage applies encodeLinear. */
+  rgba: Node<"vec4">;
+  supportRadius: Node<"float">;
+  /** A wide kernel's low 16 bits hold its edge fade as a half. */
+  supportRadiusSquared: Node<"float">;
+  kernelPower: Node<"float">;
 };
 /** Shared projection for vertex and compute paths. Call inside a TSL Fn. */
-export declare function createProjectionProgram(uniforms: Uniforms, view: ProjectionView): (source: ProjectionInput, includeColor?: boolean) => SplatProjection;
+export declare function createProjectionProgram(
+  uniforms: Uniforms,
+  view: ProjectionView,
+): (source: ProjectionInput, includeColor?: boolean) => SplatProjection;
 export {};

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

@@ -1,14 +1,26 @@
-import { TextureNode, WebGPURenderer } from 'three/webgpu';
-import { SplatMaterialOptions } from '../backend.cjs';
-import { Uniforms } from '../uniforms.cjs';
-import { ProjectedVertexData, SplatNodeMaterial } from './SplatMaterial.cjs';
 import type * as THREE from "three";
+import type { TextureNode, WebGPURenderer } from "three/webgpu";
+import type { SplatMaterialOptions } from "../backend.cjs";
+import type { Uniforms } from "../uniforms.cjs";
+import type {
+  ProjectedVertexData,
+  SplatNodeMaterial,
+} from "./SplatMaterial.cjs";
 /** Drawing shared by both WebGPURenderer backends. */
 export declare class NodeSplatBackend {
-    readonly renderer: WebGPURenderer;
-    readonly sortedMaterial: SplatNodeMaterial;
-    readonly stochasticMaterial: SplatNodeMaterial;
-    constructor(renderer: WebGPURenderer, uniforms: Uniforms, options: SplatMaterialOptions, orderingNode?: TextureNode<"uvec4">, vertexData?: (camera: THREE.Camera, stochastic: boolean) => ProjectedVertexData);
-    selectMaterial(stochastic: boolean): SplatNodeMaterial;
-    dispose(): void;
+  readonly renderer: WebGPURenderer;
+  readonly sortedMaterial: SplatNodeMaterial;
+  readonly stochasticMaterial: SplatNodeMaterial;
+  constructor(
+    renderer: WebGPURenderer,
+    uniforms: Uniforms,
+    options: SplatMaterialOptions,
+    orderingNode?: TextureNode<"uvec4">,
+    vertexData?: (
+      camera: THREE.Camera,
+      stochastic: boolean,
+    ) => ProjectedVertexData,
+  );
+  selectMaterial(stochastic: boolean): SplatNodeMaterial;
+  dispose(): void;
 }

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

@@ -1,14 +1,26 @@
-import { TextureNode, WebGPURenderer } from 'three/webgpu';
-import { SplatMaterialOptions } from '../backend';
-import { Uniforms } from '../uniforms';
-import { ProjectedVertexData, SplatNodeMaterial } from './SplatMaterial';
 import type * as THREE from "three";
+import type { TextureNode, WebGPURenderer } from "three/webgpu";
+import type { SplatMaterialOptions } from "../backend.js";
+import type { Uniforms } from "../uniforms.js";
+import type {
+  ProjectedVertexData,
+  SplatNodeMaterial,
+} from "./SplatMaterial.js";
 /** Drawing shared by both WebGPURenderer backends. */
 export declare class NodeSplatBackend {
-    readonly renderer: WebGPURenderer;
-    readonly sortedMaterial: SplatNodeMaterial;
-    readonly stochasticMaterial: SplatNodeMaterial;
-    constructor(renderer: WebGPURenderer, uniforms: Uniforms, options: SplatMaterialOptions, orderingNode?: TextureNode<"uvec4">, vertexData?: (camera: THREE.Camera, stochastic: boolean) => ProjectedVertexData);
-    selectMaterial(stochastic: boolean): SplatNodeMaterial;
-    dispose(): void;
+  readonly renderer: WebGPURenderer;
+  readonly sortedMaterial: SplatNodeMaterial;
+  readonly stochasticMaterial: SplatNodeMaterial;
+  constructor(
+    renderer: WebGPURenderer,
+    uniforms: Uniforms,
+    options: SplatMaterialOptions,
+    orderingNode?: TextureNode<"uvec4">,
+    vertexData?: (
+      camera: THREE.Camera,
+      stochastic: boolean,
+    ) => ProjectedVertexData,
+  );
+  selectMaterial(stochastic: boolean): SplatNodeMaterial;
+  dispose(): void;
 }

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

@@ -1,34 +1,47 @@
-import { Node, NodeMaterial, TextureNode } from 'three/webgpu';
-import { Uniforms } from '../uniforms.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { Node } from "three/webgpu";
+import type { NodeMaterial, TextureNode } from "three/webgpu";
+import type { Uniforms } from "../uniforms.cjs";
 export type ProjectedVertexData = {
-    clipPosition: Node<"vec4">;
-    /** Source color space; this material applies encodeLinear. */
-    rgba: Node<"vec4">;
-    splatUv: Node<"vec2">;
-    /** Stochastic variant only. */
-    stochasticSeed?: Node<"uint">;
-    /** A wide kernel's low 16 bits hold its edge fade as a half. */
-    supportRadiusSquared: Node<"float">;
-    kernelPower: Node<"float">;
-    viewportOrigin: Node<"vec2">;
+  clipPosition: Node<"vec4">;
+  /** Source color space; this material applies encodeLinear. */
+  rgba: Node<"vec4">;
+  splatUv: Node<"vec2">;
+  /** Stochastic variant only. */
+  stochasticSeed?: Node<"uint">;
+  /** A wide kernel's low 16 bits hold its edge fade as a half. */
+  supportRadiusSquared: Node<"float">;
+  kernelPower: Node<"float">;
+  viewportOrigin: Node<"vec2">;
 };
 export type SplatNodeMaterial = NodeMaterial & {
-    uniforms: Uniforms;
+  uniforms: Uniforms;
 };
 /**
  * Sorted and stochastic variants compile separate graphs, so sorted drawing
  * carries no coverage varyings, seed loads or mode branches.
  */
-export declare function createSplatNodeMaterial({ uniforms, orderingNode, vertexData, premultipliedAlpha, transparent, depthTest, depthWrite, stochastic, }: {
-    uniforms: Uniforms;
-    /** CPU ordering for drawing from accumulator textures. */
-    orderingNode?: TextureNode<"uvec4">;
-    /** Replaces accumulator projection, e.g. with a GPU projection cache. */
-    vertexData?: (camera: THREE.Camera, stochastic: boolean) => ProjectedVertexData;
-    premultipliedAlpha: boolean;
-    transparent: boolean;
-    depthTest: boolean;
-    depthWrite: boolean;
-    stochastic: boolean;
+export declare function createSplatNodeMaterial({
+  uniforms,
+  orderingNode,
+  vertexData,
+  premultipliedAlpha,
+  transparent,
+  depthTest,
+  depthWrite,
+  stochastic,
+}: {
+  uniforms: Uniforms;
+  /** CPU ordering for drawing from accumulator textures. */
+  orderingNode?: TextureNode<"uvec4">;
+  /** Replaces accumulator projection, e.g. with a GPU projection cache. */
+  vertexData?: (
+    camera: THREE.Camera,
+    stochastic: boolean,
+  ) => ProjectedVertexData;
+  premultipliedAlpha: boolean;
+  transparent: boolean;
+  depthTest: boolean;
+  depthWrite: boolean;
+  stochastic: boolean;
 }): SplatNodeMaterial;

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

@@ -1,34 +1,47 @@
-import { Node, NodeMaterial, TextureNode } from 'three/webgpu';
-import { Uniforms } from '../uniforms';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { Node } from "three/webgpu";
+import type { NodeMaterial, TextureNode } from "three/webgpu";
+import type { Uniforms } from "../uniforms.js";
 export type ProjectedVertexData = {
-    clipPosition: Node<"vec4">;
-    /** Source color space; this material applies encodeLinear. */
-    rgba: Node<"vec4">;
-    splatUv: Node<"vec2">;
-    /** Stochastic variant only. */
-    stochasticSeed?: Node<"uint">;
-    /** A wide kernel's low 16 bits hold its edge fade as a half. */
-    supportRadiusSquared: Node<"float">;
-    kernelPower: Node<"float">;
-    viewportOrigin: Node<"vec2">;
+  clipPosition: Node<"vec4">;
+  /** Source color space; this material applies encodeLinear. */
+  rgba: Node<"vec4">;
+  splatUv: Node<"vec2">;
+  /** Stochastic variant only. */
+  stochasticSeed?: Node<"uint">;
+  /** A wide kernel's low 16 bits hold its edge fade as a half. */
+  supportRadiusSquared: Node<"float">;
+  kernelPower: Node<"float">;
+  viewportOrigin: Node<"vec2">;
 };
 export type SplatNodeMaterial = NodeMaterial & {
-    uniforms: Uniforms;
+  uniforms: Uniforms;
 };
 /**
  * Sorted and stochastic variants compile separate graphs, so sorted drawing
  * carries no coverage varyings, seed loads or mode branches.
  */
-export declare function createSplatNodeMaterial({ uniforms, orderingNode, vertexData, premultipliedAlpha, transparent, depthTest, depthWrite, stochastic, }: {
-    uniforms: Uniforms;
-    /** CPU ordering for drawing from accumulator textures. */
-    orderingNode?: TextureNode<"uvec4">;
-    /** Replaces accumulator projection, e.g. with a GPU projection cache. */
-    vertexData?: (camera: THREE.Camera, stochastic: boolean) => ProjectedVertexData;
-    premultipliedAlpha: boolean;
-    transparent: boolean;
-    depthTest: boolean;
-    depthWrite: boolean;
-    stochastic: boolean;
+export declare function createSplatNodeMaterial({
+  uniforms,
+  orderingNode,
+  vertexData,
+  premultipliedAlpha,
+  transparent,
+  depthTest,
+  depthWrite,
+  stochastic,
+}: {
+  uniforms: Uniforms;
+  /** CPU ordering for drawing from accumulator textures. */
+  orderingNode?: TextureNode<"uvec4">;
+  /** Replaces accumulator projection, e.g. with a GPU projection cache. */
+  vertexData?: (
+    camera: THREE.Camera,
+    stochastic: boolean,
+  ) => ProjectedVertexData;
+  premultipliedAlpha: boolean;
+  transparent: boolean;
+  depthTest: boolean;
+  depthWrite: boolean;
+  stochastic: boolean;
 }): SplatNodeMaterial;

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

@@ -1,18 +1,56 @@
-import { Node, TextureNode, UniformNode } from 'three/webgpu';
-import { Uniforms } from '../uniforms.cjs';
-import * as THREE from "three";
-export { N } from './tslCompat.cjs';
+import type * as THREE from "three";
+import type { Node, TSL, TextureNode, UniformNode } from "three/webgpu";
+import type { Uniforms } from "../uniforms.cjs";
+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">>;