gaussian-splat-lite 0.1.0

package/dist/types/SplatGeometry.d.ts

@@ -0,0 +1,4 @@
+import * as THREE from "three";
+export declare class SplatGeometry extends THREE.InstancedBufferGeometry {
+    constructor();
+}

package/dist/types/SplatLoader.d.cts

@@ -0,0 +1,31 @@
+import { Loader } from 'three';
+import { SplatMesh } from './SplatMesh.cjs';
+import { Splats } from './Splats.cjs';
+import { SplatFileType } from './defines.cjs';
+export declare class SplatLoader extends Loader {
+    load(url: string, onLoad?: (decoded: Splats) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
+    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Splats>;
+    parse(splats: Splats): SplatMesh;
+    loadInternal({ splats, url, fileBytes, fileType, fileName, stream, streamLength, onLoad, onProgress, onError, }: {
+        splats?: Splats;
+        url?: string;
+        fileBytes?: Uint8Array | ArrayBuffer;
+        fileType?: SplatFileType;
+        fileName?: string;
+        stream?: ReadableStream;
+        streamLength?: number;
+        onLoad?: (decoded: Splats) => void;
+        onProgress?: (event: ProgressEvent) => void;
+        onError?: (error: unknown) => void;
+    }): void;
+    loadInternalAsync({ splats, url, fileBytes, fileType, fileName, stream, streamLength, onProgress, }: {
+        splats?: Splats;
+        url?: string;
+        fileBytes?: Uint8Array | ArrayBuffer;
+        fileType?: SplatFileType;
+        fileName?: string;
+        stream?: ReadableStream;
+        streamLength?: number;
+        onProgress?: (event: ProgressEvent) => void;
+    }): Promise<Splats>;
+}

package/dist/types/SplatLoader.d.ts

@@ -0,0 +1,31 @@
+import { Loader } from 'three';
+import { SplatMesh } from './SplatMesh';
+import { Splats } from './Splats';
+import { SplatFileType } from './defines';
+export declare class SplatLoader extends Loader {
+    load(url: string, onLoad?: (decoded: Splats) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
+    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Splats>;
+    parse(splats: Splats): SplatMesh;
+    loadInternal({ splats, url, fileBytes, fileType, fileName, stream, streamLength, onLoad, onProgress, onError, }: {
+        splats?: Splats;
+        url?: string;
+        fileBytes?: Uint8Array | ArrayBuffer;
+        fileType?: SplatFileType;
+        fileName?: string;
+        stream?: ReadableStream;
+        streamLength?: number;
+        onLoad?: (decoded: Splats) => void;
+        onProgress?: (event: ProgressEvent) => void;
+        onError?: (error: unknown) => void;
+    }): void;
+    loadInternalAsync({ splats, url, fileBytes, fileType, fileName, stream, streamLength, onProgress, }: {
+        splats?: Splats;
+        url?: string;
+        fileBytes?: Uint8Array | ArrayBuffer;
+        fileType?: SplatFileType;
+        fileName?: string;
+        stream?: ReadableStream;
+        streamLength?: number;
+        onProgress?: (event: ProgressEvent) => void;
+    }): Promise<Splats>;
+}

package/dist/types/SplatMesh.d.cts

@@ -0,0 +1,74 @@
+import { SplatEdit, SplatEdits } from './SplatEdit.cjs';
+import { SplatSource } from './SplatSource.cjs';
+import { Splats } from './Splats.cjs';
+import { SplatFileType } from './defines.cjs';
+import * as THREE from "three";
+export type { SplatSource } from './SplatSource.cjs';
+export type SplatMeshOptions = {
+    url?: string;
+    fileBytes?: Uint8Array | ArrayBuffer;
+    fileType?: SplatFileType;
+    fileName?: string;
+    stream?: ReadableStream;
+    streamLength?: number;
+    splats?: SplatSource;
+    maxSplats?: number;
+    constructSplats?: (splats: Splats) => Promise<void> | void;
+    onProgress?: (event: ProgressEvent) => void;
+    onLoad?: (mesh: SplatMesh) => Promise<void> | void;
+    editable?: boolean;
+    raycastable?: boolean;
+    minRaycastOpacity?: number;
+    onFrame?: (context: {
+        mesh: SplatMesh;
+        time: number;
+        deltaTime: number;
+    }) => void;
+};
+export type SplatMeshFrameContext = {
+    time: number;
+    deltaTime: number;
+    camera: THREE.Camera;
+    globalEdits: SplatEdit[];
+};
+/** A scene object backed by a fixed encoded splat source and RGBA SDF edits. */
+export declare class SplatMesh extends THREE.Object3D {
+    initialized: Promise<SplatMesh>;
+    isInitialized: boolean;
+    splats?: SplatSource;
+    numSplats: number;
+    recolor: THREE.Color;
+    opacity: number;
+    maxSh: number;
+    edits: SplatEdit[] | null;
+    editable: boolean;
+    raycastable: boolean;
+    minRaycastOpacity: number;
+    sdfEdits: SplatEdits | null;
+    onFrame?: SplatMeshOptions["onFrame"];
+    version: number;
+    sortVersion: number;
+    mappingVersion: number;
+    private lastSource?;
+    private lastNumSplats;
+    private lastMaxSh;
+    private lastMatrixWorld;
+    private hasLastMatrixWorld;
+    private lastRecolor;
+    private viewOrigin;
+    private lastViewOrigin;
+    private sdfCoordinateOrigin;
+    constructor(options?: SplatMeshOptions);
+    private asyncInitialize;
+    pushSplat(center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color): void;
+    forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
+    dispose(): void;
+    getBoundingBox(centersOnly?: boolean): THREE.Box3;
+    frameUpdate({ time, deltaTime, camera, globalEdits }: SplatMeshFrameContext): void;
+    updateVersion({ sort }?: {
+        sort?: boolean;
+    }): void;
+    updateMappingVersion(): void;
+    set needsUpdate(value: boolean);
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}

package/dist/types/SplatMesh.d.ts

@@ -0,0 +1,74 @@
+import { SplatEdit, SplatEdits } from './SplatEdit';
+import { SplatSource } from './SplatSource';
+import { Splats } from './Splats';
+import { SplatFileType } from './defines';
+import * as THREE from "three";
+export type { SplatSource } from './SplatSource';
+export type SplatMeshOptions = {
+    url?: string;
+    fileBytes?: Uint8Array | ArrayBuffer;
+    fileType?: SplatFileType;
+    fileName?: string;
+    stream?: ReadableStream;
+    streamLength?: number;
+    splats?: SplatSource;
+    maxSplats?: number;
+    constructSplats?: (splats: Splats) => Promise<void> | void;
+    onProgress?: (event: ProgressEvent) => void;
+    onLoad?: (mesh: SplatMesh) => Promise<void> | void;
+    editable?: boolean;
+    raycastable?: boolean;
+    minRaycastOpacity?: number;
+    onFrame?: (context: {
+        mesh: SplatMesh;
+        time: number;
+        deltaTime: number;
+    }) => void;
+};
+export type SplatMeshFrameContext = {
+    time: number;
+    deltaTime: number;
+    camera: THREE.Camera;
+    globalEdits: SplatEdit[];
+};
+/** A scene object backed by a fixed encoded splat source and RGBA SDF edits. */
+export declare class SplatMesh extends THREE.Object3D {
+    initialized: Promise<SplatMesh>;
+    isInitialized: boolean;
+    splats?: SplatSource;
+    numSplats: number;
+    recolor: THREE.Color;
+    opacity: number;
+    maxSh: number;
+    edits: SplatEdit[] | null;
+    editable: boolean;
+    raycastable: boolean;
+    minRaycastOpacity: number;
+    sdfEdits: SplatEdits | null;
+    onFrame?: SplatMeshOptions["onFrame"];
+    version: number;
+    sortVersion: number;
+    mappingVersion: number;
+    private lastSource?;
+    private lastNumSplats;
+    private lastMaxSh;
+    private lastMatrixWorld;
+    private hasLastMatrixWorld;
+    private lastRecolor;
+    private viewOrigin;
+    private lastViewOrigin;
+    private sdfCoordinateOrigin;
+    constructor(options?: SplatMeshOptions);
+    private asyncInitialize;
+    pushSplat(center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color): void;
+    forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
+    dispose(): void;
+    getBoundingBox(centersOnly?: boolean): THREE.Box3;
+    frameUpdate({ time, deltaTime, camera, globalEdits }: SplatMeshFrameContext): void;
+    updateVersion({ sort }?: {
+        sort?: boolean;
+    }): void;
+    updateMappingVersion(): void;
+    set needsUpdate(value: boolean);
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}

package/dist/types/SplatSource.d.cts

@@ -0,0 +1,23 @@
+import type * as THREE from "three";
+export type SplatShTextures = {
+    sh1?: THREE.DataArrayTexture;
+    sh2?: THREE.DataArrayTexture;
+    sh3a?: THREE.DataArrayTexture;
+    sh3b?: THREE.DataArrayTexture;
+};
+/**
+ * GPU and CPU access required by the fixed splat generation pipeline.
+ *
+ * Sources provide encoded texture data; shader construction and arbitrary
+ * per-splat modifiers are deliberately not part of this interface.
+ */
+export interface SplatSource {
+    needsUpdate: boolean;
+    dispose(): void;
+    getNumSplats(): number;
+    getNumSh(): number;
+    getSplatTextures(): readonly [THREE.DataArrayTexture, THREE.DataArrayTexture];
+    getShTextures(): SplatShTextures;
+    forEachCenter(callback: (index: number, x: number, y: number, z: number) => void): void;
+    forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
+}

package/dist/types/SplatSource.d.ts

@@ -0,0 +1,23 @@
+import type * as THREE from "three";
+export type SplatShTextures = {
+    sh1?: THREE.DataArrayTexture;
+    sh2?: THREE.DataArrayTexture;
+    sh3a?: THREE.DataArrayTexture;
+    sh3b?: THREE.DataArrayTexture;
+};
+/**
+ * GPU and CPU access required by the fixed splat generation pipeline.
+ *
+ * Sources provide encoded texture data; shader construction and arbitrary
+ * per-splat modifiers are deliberately not part of this interface.
+ */
+export interface SplatSource {
+    needsUpdate: boolean;
+    dispose(): void;
+    getNumSplats(): number;
+    getNumSh(): number;
+    getSplatTextures(): readonly [THREE.DataArrayTexture, THREE.DataArrayTexture];
+    getShTextures(): SplatShTextures;
+    forEachCenter(callback: (index: number, x: number, y: number, z: number) => void): void;
+    forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
+}

package/dist/types/SplatWorker.d.cts

@@ -0,0 +1,30 @@
+import { RpcHandlers } from './worker.cjs';
+type PromiseRecord = {
+    resolve: (value: unknown) => void;
+    reject: (reason?: unknown) => void;
+    onStatus?: (data: unknown) => void | Promise<void>;
+    statusQueue: Promise<void>;
+};
+export declare class SplatWorker {
+    worker: Worker;
+    messages: Record<number, PromiseRecord>;
+    static currentId: number;
+    constructor();
+    onMessage(event: MessageEvent): void;
+    call<Name extends keyof RpcHandlers>(name: Name, args: Parameters<RpcHandlers[Name]>[0], options?: {
+        onStatus?: (data: unknown) => void | Promise<void>;
+    }): Promise<Awaited<ReturnType<RpcHandlers[Name]>>>;
+    dispose(): void;
+}
+declare class SplatWorkerPool {
+    maxWorkers: number;
+    numWorkers: number;
+    freelist: SplatWorker[];
+    queue: ((worker: SplatWorker) => void)[];
+    constructor(maxWorkers?: number);
+    withWorker<T>(callback: (worker: SplatWorker) => Promise<T>): Promise<T>;
+    allocWorker(): Promise<SplatWorker>;
+    freeWorker(worker: SplatWorker): void;
+}
+export declare const workerPool: SplatWorkerPool;
+export {};

package/dist/types/SplatWorker.d.ts

@@ -0,0 +1,30 @@
+import { RpcHandlers } from './worker';
+type PromiseRecord = {
+    resolve: (value: unknown) => void;
+    reject: (reason?: unknown) => void;
+    onStatus?: (data: unknown) => void | Promise<void>;
+    statusQueue: Promise<void>;
+};
+export declare class SplatWorker {
+    worker: Worker;
+    messages: Record<number, PromiseRecord>;
+    static currentId: number;
+    constructor();
+    onMessage(event: MessageEvent): void;
+    call<Name extends keyof RpcHandlers>(name: Name, args: Parameters<RpcHandlers[Name]>[0], options?: {
+        onStatus?: (data: unknown) => void | Promise<void>;
+    }): Promise<Awaited<ReturnType<RpcHandlers[Name]>>>;
+    dispose(): void;
+}
+declare class SplatWorkerPool {
+    maxWorkers: number;
+    numWorkers: number;
+    freelist: SplatWorker[];
+    queue: ((worker: SplatWorker) => void)[];
+    constructor(maxWorkers?: number);
+    withWorker<T>(callback: (worker: SplatWorker) => Promise<T>): Promise<T>;
+    allocWorker(): Promise<SplatWorker>;
+    freeWorker(worker: SplatWorker): void;
+}
+export declare const workerPool: SplatWorkerPool;
+export {};

package/dist/types/Splats.d.cts

@@ -0,0 +1,54 @@
+import { SplatShTextures, SplatSource } from './SplatSource.cjs';
+import { SplatFileType } from './defines.cjs';
+import * as THREE from "three";
+export type SplatsOptions = {
+    url?: string;
+    fileBytes?: Uint8Array | ArrayBuffer;
+    fileType?: SplatFileType;
+    fileName?: string;
+    stream?: ReadableStream;
+    streamLength?: number;
+    maxSplats?: number;
+    splatArrays?: [Uint32Array, Uint32Array];
+    numSplats?: number;
+    construct?: (splats: Splats) => Promise<void> | void;
+    onProgress?: (event: ProgressEvent) => void;
+    extra?: Record<string, unknown>;
+};
+/** A mutable splat source with two 16-byte texture records per splat. */
+export declare class Splats implements SplatSource {
+    maxSplats: number;
+    numSplats: number;
+    splatArrays: [Uint32Array, Uint32Array];
+    extra: Record<string, unknown>;
+    initialized: Promise<Splats>;
+    isInitialized: boolean;
+    needsUpdate: boolean;
+    private textures;
+    private shTextures;
+    constructor(options?: SplatsOptions);
+    reinitialize(options: SplatsOptions): void;
+    initialize(options: SplatsOptions): void;
+    private asyncInitialize;
+    dispose(): void;
+    private disposeTextures;
+    getNumSplats(): number;
+    getNumSh(): 0 | 1 | 2 | 3;
+    ensureSplats(numSplats: number): [Uint32Array, Uint32Array];
+    getSplat(index: number): {
+        center: THREE.Vector3;
+        scales: THREE.Vector3;
+        quaternion: THREE.Quaternion;
+        color: THREE.Color;
+        opacity: number;
+    };
+    setSplat(index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color): void;
+    pushSplat(center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color): void;
+    forEachCenter(callback: (index: number, x: number, y: number, z: number) => void): void;
+    forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
+    getSplatTextures(): readonly [THREE.DataArrayTexture, THREE.DataArrayTexture];
+    private disposeMainTextures;
+    getShTextures(): SplatShTextures;
+    private ensureShTexture;
+    static emptyTexture: THREE.DataArrayTexture;
+}

package/dist/types/Splats.d.ts

@@ -0,0 +1,54 @@
+import { SplatShTextures, SplatSource } from './SplatSource';
+import { SplatFileType } from './defines';
+import * as THREE from "three";
+export type SplatsOptions = {
+    url?: string;
+    fileBytes?: Uint8Array | ArrayBuffer;
+    fileType?: SplatFileType;
+    fileName?: string;
+    stream?: ReadableStream;
+    streamLength?: number;
+    maxSplats?: number;
+    splatArrays?: [Uint32Array, Uint32Array];
+    numSplats?: number;
+    construct?: (splats: Splats) => Promise<void> | void;
+    onProgress?: (event: ProgressEvent) => void;
+    extra?: Record<string, unknown>;
+};
+/** A mutable splat source with two 16-byte texture records per splat. */
+export declare class Splats implements SplatSource {
+    maxSplats: number;
+    numSplats: number;
+    splatArrays: [Uint32Array, Uint32Array];
+    extra: Record<string, unknown>;
+    initialized: Promise<Splats>;
+    isInitialized: boolean;
+    needsUpdate: boolean;
+    private textures;
+    private shTextures;
+    constructor(options?: SplatsOptions);
+    reinitialize(options: SplatsOptions): void;
+    initialize(options: SplatsOptions): void;
+    private asyncInitialize;
+    dispose(): void;
+    private disposeTextures;
+    getNumSplats(): number;
+    getNumSh(): 0 | 1 | 2 | 3;
+    ensureSplats(numSplats: number): [Uint32Array, Uint32Array];
+    getSplat(index: number): {
+        center: THREE.Vector3;
+        scales: THREE.Vector3;
+        quaternion: THREE.Quaternion;
+        color: THREE.Color;
+        opacity: number;
+    };
+    setSplat(index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color): void;
+    pushSplat(center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color): void;
+    forEachCenter(callback: (index: number, x: number, y: number, z: number) => void): void;
+    forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
+    getSplatTextures(): readonly [THREE.DataArrayTexture, THREE.DataArrayTexture];
+    private disposeMainTextures;
+    getShTextures(): SplatShTextures;
+    private ensureShTexture;
+    static emptyTexture: THREE.DataArrayTexture;
+}

package/dist/types/cameraRelative.d.cts

@@ -0,0 +1,22 @@
+import { SplatAccumulator } from './SplatAccumulator.cjs';
+import * as THREE from "three";
+/**
+ * Re-expresses an affine transform so it consumes positions relative to
+ * `origin` instead of absolute world positions.
+ *
+ * If `matrix` maps p to A * p + t, the rebased matrix maps (p - origin) to
+ * A * (p - origin) + (A * origin + t), which is the same result without doing
+ * a large-coordinate subtraction in float32 shader code.
+ */
+export declare function rebaseAffineTransform(matrix: THREE.Matrix4, origin: THREE.Vector3): THREE.Matrix4;
+/**
+ * Builds persistent sort centers relative to each mesh origin. Keeping the
+ * Float64 world origin separate lets the worker form a fresh camera-to-mesh
+ * offset for every sort without rebuilding the per-splat Float32 data.
+ */
+export declare function buildSortCenters(current: SplatAccumulator): {
+    centers: Float32Array<ArrayBuffer>;
+    rangeBases: Uint32Array<ArrayBuffer>;
+    rangeCounts: Uint32Array<ArrayBuffer>;
+    rangeOrigins: Float64Array<ArrayBuffer>;
+};

package/dist/types/cameraRelative.d.ts

@@ -0,0 +1,22 @@
+import { SplatAccumulator } from './SplatAccumulator';
+import * as THREE from "three";
+/**
+ * Re-expresses an affine transform so it consumes positions relative to
+ * `origin` instead of absolute world positions.
+ *
+ * If `matrix` maps p to A * p + t, the rebased matrix maps (p - origin) to
+ * A * (p - origin) + (A * origin + t), which is the same result without doing
+ * a large-coordinate subtraction in float32 shader code.
+ */
+export declare function rebaseAffineTransform(matrix: THREE.Matrix4, origin: THREE.Vector3): THREE.Matrix4;
+/**
+ * Builds persistent sort centers relative to each mesh origin. Keeping the
+ * Float64 world origin separate lets the worker form a fresh camera-to-mesh
+ * offset for every sort without rebuilding the per-splat Float32 data.
+ */
+export declare function buildSortCenters(current: SplatAccumulator): {
+    centers: Float32Array<ArrayBuffer>;
+    rangeBases: Uint32Array<ArrayBuffer>;
+    rangeCounts: Uint32Array<ArrayBuffer>;
+    rangeOrigins: Float64Array<ArrayBuffer>;
+};

package/dist/types/defines.d.cts

@@ -0,0 +1,22 @@
+export declare const LN_SCALE_MIN = -12;
+export declare const LN_SCALE_MAX = 9;
+export declare const SPLAT_TEX_WIDTH_BITS = 11;
+export declare const SPLAT_TEX_HEIGHT_BITS = 11;
+export declare const SPLAT_TEX_WIDTH: number;
+export declare const SPLAT_TEX_HEIGHT: number;
+export declare const SPLAT_TEX_MIN_HEIGHT = 1;
+export declare enum SplatFileType {
+    PLY = "ply",
+    SPZ = "spz"
+}
+export type SplatExtra = {
+    sh1?: Uint32Array;
+    sh2?: Uint32Array;
+    sh3a?: Uint32Array;
+    sh3b?: Uint32Array;
+};
+export type SplatResult = {
+    numSplats: number;
+    splatArrays: [Uint32Array, Uint32Array];
+    extra: SplatExtra;
+};

package/dist/types/defines.d.ts

@@ -0,0 +1,22 @@
+export declare const LN_SCALE_MIN = -12;
+export declare const LN_SCALE_MAX = 9;
+export declare const SPLAT_TEX_WIDTH_BITS = 11;
+export declare const SPLAT_TEX_HEIGHT_BITS = 11;
+export declare const SPLAT_TEX_WIDTH: number;
+export declare const SPLAT_TEX_HEIGHT: number;
+export declare const SPLAT_TEX_MIN_HEIGHT = 1;
+export declare enum SplatFileType {
+    PLY = "ply",
+    SPZ = "spz"
+}
+export type SplatExtra = {
+    sh1?: Uint32Array;
+    sh2?: Uint32Array;
+    sh3a?: Uint32Array;
+    sh3b?: Uint32Array;
+};
+export type SplatResult = {
+    numSplats: number;
+    splatArrays: [Uint32Array, Uint32Array];
+    extra: SplatExtra;
+};

package/dist/types/index.d.cts

@@ -0,0 +1,12 @@
+export { GaussianSplatRenderer, type GaussianSplatRendererOptions, } from './GaussianSplatRenderer.cjs';
+export { SplatAccumulator, type SplatMapping, } from './SplatAccumulator.cjs';
+export { SplatLoader } from './SplatLoader.cjs';
+export type { SplatWorker } from './SplatWorker.cjs';
+export { Splats, type SplatsOptions } from './Splats.cjs';
+export { SplatMesh, type SplatMeshFrameContext, type SplatMeshOptions, } from './SplatMesh.cjs';
+export type { SplatSource, SplatShTextures, } from './SplatSource.cjs';
+export { SplatEdit, type SplatEditGroup, type SplatEditOptions, SplatEditSdf, type SplatEditSdfOptions, SplatEditSdfType, SplatEditRgbaBlendMode, SplatEdits, } from './SplatEdit.cjs';
+export { toHalf, fromHalf, } from './utils.cjs';
+export * as utils from './utils.cjs';
+export { LN_SCALE_MIN, LN_SCALE_MAX, SplatFileType } from './defines.cjs';
+export * as defines from './defines.cjs';

package/dist/types/index.d.mts

@@ -0,0 +1 @@
+export * from "./index.cjs";

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+export { GaussianSplatRenderer, type GaussianSplatRendererOptions, } from './GaussianSplatRenderer';
+export { SplatAccumulator, type SplatMapping, } from './SplatAccumulator';
+export { SplatLoader } from './SplatLoader';
+export type { SplatWorker } from './SplatWorker';
+export { Splats, type SplatsOptions } from './Splats';
+export { SplatMesh, type SplatMeshFrameContext, type SplatMeshOptions, } from './SplatMesh';
+export type { SplatSource, SplatShTextures, } from './SplatSource';
+export { SplatEdit, type SplatEditGroup, type SplatEditOptions, SplatEditSdf, type SplatEditSdfOptions, SplatEditSdfType, SplatEditRgbaBlendMode, SplatEdits, } from './SplatEdit';
+export { toHalf, fromHalf, } from './utils';
+export * as utils from './utils';
+export { LN_SCALE_MIN, LN_SCALE_MAX, SplatFileType } from './defines';
+export * as defines from './defines';

package/dist/types/shaders.d.cts

@@ -0,0 +1 @@
+export declare function getShaders(): Record<string, string>;

package/dist/types/shaders.d.ts

@@ -0,0 +1 @@
+export declare function getShaders(): Record<string, string>;

package/dist/types/splatTransform.d.cts

@@ -0,0 +1,10 @@
+import * as THREE from "three";
+/**
+ * Extracts the positive per-axis scale and approximate rotation used by the
+ * PlayCanvas-style splat work-buffer transform.
+ *
+ * Unlike Matrix4.decompose(), this remains finite when a model scale axis is
+ * zero. When possible, the missing basis axis is reconstructed from the other
+ * two so a model-level collapse can still produce a correctly oriented 2DGS.
+ */
+export declare function decomposeSplatTransform(matrix: THREE.Matrix4, scale: THREE.Vector3, rotation: THREE.Quaternion): void;

package/dist/types/splatTransform.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from "three";
+/**
+ * Extracts the positive per-axis scale and approximate rotation used by the
+ * PlayCanvas-style splat work-buffer transform.
+ *
+ * Unlike Matrix4.decompose(), this remains finite when a model scale axis is
+ * zero. When possible, the missing basis axis is reconstructed from the other
+ * two so a model-level collapse can still produce a correctly oriented 2DGS.
+ */
+export declare function decomposeSplatTransform(matrix: THREE.Matrix4, scale: THREE.Vector3, rotation: THREE.Quaternion): void;

package/dist/types/utils.d.cts

@@ -0,0 +1,33 @@
+import * as THREE from "three";
+export declare const threeRevision: number;
+export declare const threeMrtArray: boolean;
+export declare function floatBitsToUint(f: number): number;
+export declare function uintBitsToFloat(u: number): number;
+export declare const toHalf: typeof toHalfNative;
+export declare const fromHalf: typeof fromHalfNative;
+declare function toHalfNative(f: number): number;
+declare function fromHalfNative(u: number): number;
+export declare function getTransferable(ctx: unknown): Transferable[];
+export declare function encodeSplat(splatArrays: [Uint32Array, Uint32Array], index: number, x: number, y: number, z: number, scaleX: number, scaleY: number, scaleZ: number, quatX: number, quatY: number, quatZ: number, quatW: number, opacity: number, r: number, g: number, b: number): void;
+export declare function decodeSplat(splatArrays: [Uint32Array, Uint32Array], index: number): {
+    center: THREE.Vector3;
+    scales: THREE.Vector3;
+    quaternion: THREE.Quaternion;
+    color: THREE.Color;
+    opacity: number;
+};
+export declare function getTextureSize(numSplats: number): {
+    width: number;
+    height: number;
+    depth: number;
+    maxSplats: number;
+};
+export declare const IDENT_VERTEX_SHADER = "\nprecision highp float;\n\nin vec3 position;\n\nvoid main() {\n  gl_Position = vec4(position.xy, 0.0, 1.0);\n}\n";
+export declare function encodeQuatOctXy1010R12(qx: number, qy: number, qz: number, qw: number): number;
+export declare function decodeQuatOctXy1010R12(encoded: number, out: THREE.Quaternion): THREE.Quaternion;
+export declare function uploadU32DataTextureRows(renderer: THREE.WebGLRenderer, texture: THREE.Texture, width: number, rows: number, data: Uint32Array): void;
+export declare function resolveTimer(timer?: THREE.Timer): {
+    timer: THREE.Timer;
+    ownsTimer: boolean;
+};
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,33 @@
+import * as THREE from "three";
+export declare const threeRevision: number;
+export declare const threeMrtArray: boolean;
+export declare function floatBitsToUint(f: number): number;
+export declare function uintBitsToFloat(u: number): number;
+export declare const toHalf: typeof toHalfNative;
+export declare const fromHalf: typeof fromHalfNative;
+declare function toHalfNative(f: number): number;
+declare function fromHalfNative(u: number): number;
+export declare function getTransferable(ctx: unknown): Transferable[];
+export declare function encodeSplat(splatArrays: [Uint32Array, Uint32Array], index: number, x: number, y: number, z: number, scaleX: number, scaleY: number, scaleZ: number, quatX: number, quatY: number, quatZ: number, quatW: number, opacity: number, r: number, g: number, b: number): void;
+export declare function decodeSplat(splatArrays: [Uint32Array, Uint32Array], index: number): {
+    center: THREE.Vector3;
+    scales: THREE.Vector3;
+    quaternion: THREE.Quaternion;
+    color: THREE.Color;
+    opacity: number;
+};
+export declare function getTextureSize(numSplats: number): {
+    width: number;
+    height: number;
+    depth: number;
+    maxSplats: number;
+};
+export declare const IDENT_VERTEX_SHADER = "\nprecision highp float;\n\nin vec3 position;\n\nvoid main() {\n  gl_Position = vec4(position.xy, 0.0, 1.0);\n}\n";
+export declare function encodeQuatOctXy1010R12(qx: number, qy: number, qz: number, qw: number): number;
+export declare function decodeQuatOctXy1010R12(encoded: number, out: THREE.Quaternion): THREE.Quaternion;
+export declare function uploadU32DataTextureRows(renderer: THREE.WebGLRenderer, texture: THREE.Texture, width: number, rows: number, data: Uint32Array): void;
+export declare function resolveTimer(timer?: THREE.Timer): {
+    timer: THREE.Timer;
+    ownsTimer: boolean;
+};
+export {};