gaussian-splat-lite 1.2.2 → 1.3.0

package/dist/types/data/IndexedSplats.d.ts

@@ -1,68 +1,86 @@
-import { SplatOpacityTable } from './SplatOpacityTable';
-import { Splats, SplatsOptions } from './Splats';
-import { ReorderedSplatResult, SplatResult } from './defines';
-import { RaycastRangeCallback, SplatRaycastQuery } from './raycast';
-import { decodeSplat } from './unpack';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { SplatOpacityTable } from "./SplatOpacityTable.js";
+import { Splats, type SplatsOptions } from "./Splats.js";
+import type { ReorderedSplatResult, SplatResult } from "./defines.js";
+import type { RaycastRangeCallback, SplatRaycastQuery } from "./raycast.js";
+import type { decodeSplat } from "./unpack.js";
 type IndexedSplatsOptions = {
-    capacity: number;
-    layerSize: number;
-    numSh: number;
-    blockBits: number;
+  capacity: number;
+  layerSize: number;
+  numSh: number;
+  blockBits: number;
 };
 type DecodedSplat = ReturnType<typeof decodeSplat>;
 type DecodedSplatWithSh = DecodedSplat & {
-    sh: THREE.Color[];
+  sh: THREE.Color[];
 };
 /** Fixed packed storage with one visible-index contract for rendering and CPU reads.
  * Fades affect display only: records returned to picking retain their source opacity. */
 export declare abstract class IndexedSplats extends Splats {
-    readonly layerSize: number;
-    readonly numSh: 0 | 1 | 2 | 3;
-    protected readonly opacities: SplatOpacityTable;
-    protected sourceIndices: Uint32Array<ArrayBuffer>;
-    protected visibleIndices: Uint32Array;
-    private sourceArrays;
-    private sourceCenters;
-    private sourceTextures;
-    private indexTexture;
-    private readonly blockBits;
-    private disposed;
-    private readonly spatialChunks;
-    private spatialBoundsBytes;
-    constructor({ capacity, layerSize, numSh, blockBits }: IndexedSplatsOptions);
-    protected assertLive(): void;
-    initialize(options?: SplatsOptions): Promise<Splats>;
-    /** Range-based sources can materialize their visible map lazily. */
-    protected ensureIndices(): void;
-    /** Each source updates its bounds independently of the visible-index map. */
-    protected commitIndices(indices: Uint32Array): void;
-    /** Reserve index storage and mark it for upload; fill the first count entries synchronously. */
-    protected prepareIndices(count: number): Uint32Array<ArrayBuffer>;
-    /** Copies packed records. Input buffers remain caller-owned for both formats. */
-    protected writeRecords(start: number, data: ReorderedSplatResult, allocation: number): void;
-    private getStorageIndex;
-    getSourceIndex(index: number): number;
-    private checkVisibleRange;
-    getNumSh(): 0 | 1 | 2 | 3;
-    private get textureByteLength();
-    getByteLength(): number;
-    get residentBytes(): number;
-    private center;
-    copySortCenters(target: Float32Array, targetStart: number, count: number): void;
-    protected releaseSpatialBounds(start: number): void;
-    forEachRaycastRange(query: SplatRaycastQuery, callback: RaycastRangeCallback): void;
-    copySplatRecords(firstTarget: Uint32Array, secondTarget: Uint32Array, sourceStart: number, count: number): void;
-    getSplat(index: number): DecodedSplatWithSh;
-    getSplat(index: number, includeSh: true): DecodedSplatWithSh;
-    getSplat(index: number, includeSh: false): DecodedSplat;
-    getSplat(index: number, includeSh: boolean): DecodedSplat;
-    forEachCenter(callback: (index: number, x: number, y: number, z: number) => void): void;
-    forEachSplat(callback: Parameters<Splats["forEachSplat"]>[0]): void;
-    takeData(): SplatResult & {
-        sourceIds: Uint32Array;
-    };
-    setTextureUniforms(uniforms: Record<string, THREE.IUniform>): void;
-    dispose(): void;
+  readonly layerSize: number;
+  readonly numSh: 0 | 1 | 2 | 3;
+  protected readonly opacities: SplatOpacityTable;
+  protected sourceIndices: Uint32Array<ArrayBuffer>;
+  protected visibleIndices: Uint32Array;
+  private sourceArrays;
+  private sourceCenters;
+  private sourceTextures;
+  private indexTexture;
+  private readonly blockBits;
+  private disposed;
+  private readonly spatialChunks;
+  private spatialBoundsBytes;
+  constructor({ capacity, layerSize, numSh, blockBits }: IndexedSplatsOptions);
+  protected assertLive(): void;
+  initialize(options?: SplatsOptions): Promise<Splats>;
+  /** Range-based sources can materialize their visible map lazily. */
+  protected ensureIndices(): void;
+  /** Each source updates its bounds independently of the visible-index map. */
+  protected commitIndices(indices: Uint32Array): void;
+  /** Reserve index storage and mark it for upload; fill the first count entries synchronously. */
+  protected prepareIndices(count: number): Uint32Array<ArrayBuffer>;
+  /** Copies packed records. Input buffers remain caller-owned for both formats. */
+  protected writeRecords(
+    start: number,
+    data: ReorderedSplatResult,
+    allocation: number,
+  ): void;
+  private getStorageIndex;
+  getSourceIndex(index: number): number;
+  private checkVisibleRange;
+  getNumSh(): 0 | 3 | 2 | 1;
+  private get textureByteLength();
+  getByteLength(): number;
+  get residentBytes(): number;
+  private center;
+  copySortCenters(
+    target: Float32Array,
+    targetStart: number,
+    count: number,
+  ): void;
+  protected releaseSpatialBounds(start: number): void;
+  forEachRaycastRange(
+    query: SplatRaycastQuery,
+    callback: RaycastRangeCallback,
+  ): void;
+  copySplatRecords(
+    firstTarget: Uint32Array,
+    secondTarget: Uint32Array,
+    sourceStart: number,
+    count: number,
+  ): void;
+  getSplat(index: number): DecodedSplatWithSh;
+  getSplat(index: number, includeSh: true): DecodedSplatWithSh;
+  getSplat(index: number, includeSh: false): DecodedSplat;
+  getSplat(index: number, includeSh: boolean): DecodedSplat;
+  forEachCenter(
+    callback: (index: number, x: number, y: number, z: number) => void,
+  ): void;
+  forEachSplat(callback: Parameters<Splats["forEachSplat"]>[0]): void;
+  takeData(): SplatResult & {
+    sourceIds: Uint32Array;
+  };
+  setTextureUniforms(uniforms: Record<string, THREE.IUniform>): void;
+  dispose(): void;
 }
 export {};

package/dist/types/data/RadPagedSplats.d.cts

@@ -1,78 +1,82 @@
-import { IndexedSplats } from './IndexedSplats.cjs';
-import { ReorderedSplatResult } from './defines.cjs';
+import { IndexedSplats } from "./IndexedSplats.cjs";
+import type { ReorderedSplatResult } from "./defines.cjs";
 export type RadPagedSplatsOptions = {
-    /** Maximum records in one decoded chunk. Defaults to Spark's 65,536. */
-    pageSize?: number;
-    pageCount: number;
-    numSh: number;
-    /** Pass the device limit when known. WebGL2 guarantees at least 256. */
-    maxArrayLayers?: number;
+  /** Maximum records in one decoded chunk. Defaults to Spark's 65,536. */
+  pageSize?: number;
+  pageCount: number;
+  numSh: number;
+  /** Pass the device limit when known. WebGL2 guarantees at least 256. */
+  maxArrayLayers?: number;
 };
 /** Page ranges in a sorted, file-global cut; used only by RAD streaming. */
 export type RadSelectionRange = {
-    start: number;
-    end: number;
-    slot: number;
-    pageStart: number;
-    chunkIndex: number;
-    sourceBase: number;
+  start: number;
+  end: number;
+  slot: number;
+  pageStart: number;
+  chunkIndex: number;
+  sourceBase: number;
 };
 export type RadSelectionSnapshot = {
-    pageCount: number;
-    opacityBlocks: Uint32Array;
-    ranges: RadSelectionRange[];
+  pageCount: number;
+  opacityBlocks: Uint32Array;
+  ranges: RadSelectionRange[];
 };
 type RadPreparedCut = {
-    indices: Uint32Array;
-    selectedPages: Uint32Array;
-    centerOnlyBoundingBox: Float32Array;
-    boundingBox: Float32Array;
+  indices: Uint32Array;
+  selectedPages: Uint32Array;
+  centerOnlyBoundingBox: Float32Array;
+  boundingBox: Float32Array;
 };
 export type RadPreparedSelection = RadPreparedCut & {
-    opacityBlocks: Uint32Array;
-    dirtyLayers: Uint8Array;
-    fadeKinds: number;
-    final?: RadPreparedCut;
+  opacityBlocks: Uint32Array;
+  dirtyLayers: Uint8Array;
+  fadeKinds: number;
+  final?: RadPreparedCut;
 };
 /** One power-of-two texture layer per page, with no shared upload layers. */
-export declare function radPageTextureLayout({ pageSize, pageCount, maxArrayLayers, }: Omit<RadPagedSplatsOptions, "numSh">): {
-    pageSize: number;
-    pageStride: number;
-    pageCount: number;
-    capacity: number;
-    width: number;
-    height: number;
-    depth: number;
+export declare function radPageTextureLayout({
+  pageSize,
+  pageCount,
+  maxArrayLayers,
+}: Omit<RadPagedSplatsOptions, "numSh">): {
+  pageSize: number;
+  pageStride: number;
+  pageCount: number;
+  capacity: number;
+  width: number;
+  height: number;
+  depth: number;
 };
 /** Fixed RAD page slots; shared IndexedSplats owns rendering and CPU access. */
 export declare class RadPagedSplats extends IndexedSplats {
-    readonly pageSize: number;
-    readonly pageStride: number;
-    readonly pageCount: number;
-    private selectedPages;
-    private finalSelection?;
-    private fadeProgress;
-    private fadeKinds;
-    constructor(options: RadPagedSplatsOptions);
-    pageStart(slot: number): number;
-    /** Copies data; callers retain ownership of the packed buffers. */
-    writePage(slot: number, data: ReorderedSplatResult): void;
-    /** Remove the displayed cut when its scheduler becomes hidden. */
-    clearSelection(): boolean;
-    /** Snapshot only changed pools; never transfer live texture storage. */
-    snapshotSelection(ranges: RadSelectionRange[]): RadSelectionSnapshot;
-    /** Internal commit of worker-prepared data; the caller gives up the arrays. */
-    commitSelection(prepared: RadPreparedSelection): void;
-    /** Keep record indices, page occupancy and bounds on the same cut. */
-    private commitCut;
-    /** A normal streaming fade changes only two group coefficients. */
-    setFadeProgress(progress: number): boolean;
-    isPageSelected(slot: number): boolean;
-    /** Complete opacity changes without removing outgoing records. */
-    finishFadeIn(): boolean;
-    /** The worker already removed outgoing records from the final cut. */
-    finishFade(): boolean;
-    getByteLength(): number;
-    dispose(): void;
+  readonly pageSize: number;
+  readonly pageStride: number;
+  readonly pageCount: number;
+  private selectedPages;
+  private finalSelection?;
+  private fadeProgress;
+  private fadeKinds;
+  constructor(options: RadPagedSplatsOptions);
+  pageStart(slot: number): number;
+  /** Copies data; callers retain ownership of the packed buffers. */
+  writePage(slot: number, data: ReorderedSplatResult): void;
+  /** Remove the displayed cut when its scheduler becomes hidden. */
+  clearSelection(): boolean;
+  /** Snapshot only changed pools; never transfer live texture storage. */
+  snapshotSelection(ranges: RadSelectionRange[]): RadSelectionSnapshot;
+  /** Internal commit of worker-prepared data; the caller gives up the arrays. */
+  commitSelection(prepared: RadPreparedSelection): void;
+  /** Keep record indices, page occupancy and bounds on the same cut. */
+  private commitCut;
+  /** A normal streaming fade changes only two group coefficients. */
+  setFadeProgress(progress: number): boolean;
+  isPageSelected(slot: number): boolean;
+  /** Complete opacity changes without removing outgoing records. */
+  finishFadeIn(): boolean;
+  /** The worker already removed outgoing records from the final cut. */
+  finishFade(): boolean;
+  getByteLength(): number;
+  dispose(): void;
 }
 export {};

package/dist/types/data/RadPagedSplats.d.ts

@@ -1,78 +1,82 @@
-import { IndexedSplats } from './IndexedSplats';
-import { ReorderedSplatResult } from './defines';
+import { IndexedSplats } from "./IndexedSplats.js";
+import type { ReorderedSplatResult } from "./defines.js";
 export type RadPagedSplatsOptions = {
-    /** Maximum records in one decoded chunk. Defaults to Spark's 65,536. */
-    pageSize?: number;
-    pageCount: number;
-    numSh: number;
-    /** Pass the device limit when known. WebGL2 guarantees at least 256. */
-    maxArrayLayers?: number;
+  /** Maximum records in one decoded chunk. Defaults to Spark's 65,536. */
+  pageSize?: number;
+  pageCount: number;
+  numSh: number;
+  /** Pass the device limit when known. WebGL2 guarantees at least 256. */
+  maxArrayLayers?: number;
 };
 /** Page ranges in a sorted, file-global cut; used only by RAD streaming. */
 export type RadSelectionRange = {
-    start: number;
-    end: number;
-    slot: number;
-    pageStart: number;
-    chunkIndex: number;
-    sourceBase: number;
+  start: number;
+  end: number;
+  slot: number;
+  pageStart: number;
+  chunkIndex: number;
+  sourceBase: number;
 };
 export type RadSelectionSnapshot = {
-    pageCount: number;
-    opacityBlocks: Uint32Array;
-    ranges: RadSelectionRange[];
+  pageCount: number;
+  opacityBlocks: Uint32Array;
+  ranges: RadSelectionRange[];
 };
 type RadPreparedCut = {
-    indices: Uint32Array;
-    selectedPages: Uint32Array;
-    centerOnlyBoundingBox: Float32Array;
-    boundingBox: Float32Array;
+  indices: Uint32Array;
+  selectedPages: Uint32Array;
+  centerOnlyBoundingBox: Float32Array;
+  boundingBox: Float32Array;
 };
 export type RadPreparedSelection = RadPreparedCut & {
-    opacityBlocks: Uint32Array;
-    dirtyLayers: Uint8Array;
-    fadeKinds: number;
-    final?: RadPreparedCut;
+  opacityBlocks: Uint32Array;
+  dirtyLayers: Uint8Array;
+  fadeKinds: number;
+  final?: RadPreparedCut;
 };
 /** One power-of-two texture layer per page, with no shared upload layers. */
-export declare function radPageTextureLayout({ pageSize, pageCount, maxArrayLayers, }: Omit<RadPagedSplatsOptions, "numSh">): {
-    pageSize: number;
-    pageStride: number;
-    pageCount: number;
-    capacity: number;
-    width: number;
-    height: number;
-    depth: number;
+export declare function radPageTextureLayout({
+  pageSize,
+  pageCount,
+  maxArrayLayers,
+}: Omit<RadPagedSplatsOptions, "numSh">): {
+  pageSize: number;
+  pageStride: number;
+  pageCount: number;
+  capacity: number;
+  width: number;
+  height: number;
+  depth: number;
 };
 /** Fixed RAD page slots; shared IndexedSplats owns rendering and CPU access. */
 export declare class RadPagedSplats extends IndexedSplats {
-    readonly pageSize: number;
-    readonly pageStride: number;
-    readonly pageCount: number;
-    private selectedPages;
-    private finalSelection?;
-    private fadeProgress;
-    private fadeKinds;
-    constructor(options: RadPagedSplatsOptions);
-    pageStart(slot: number): number;
-    /** Copies data; callers retain ownership of the packed buffers. */
-    writePage(slot: number, data: ReorderedSplatResult): void;
-    /** Remove the displayed cut when its scheduler becomes hidden. */
-    clearSelection(): boolean;
-    /** Snapshot only changed pools; never transfer live texture storage. */
-    snapshotSelection(ranges: RadSelectionRange[]): RadSelectionSnapshot;
-    /** Internal commit of worker-prepared data; the caller gives up the arrays. */
-    commitSelection(prepared: RadPreparedSelection): void;
-    /** Keep record indices, page occupancy and bounds on the same cut. */
-    private commitCut;
-    /** A normal streaming fade changes only two group coefficients. */
-    setFadeProgress(progress: number): boolean;
-    isPageSelected(slot: number): boolean;
-    /** Complete opacity changes without removing outgoing records. */
-    finishFadeIn(): boolean;
-    /** The worker already removed outgoing records from the final cut. */
-    finishFade(): boolean;
-    getByteLength(): number;
-    dispose(): void;
+  readonly pageSize: number;
+  readonly pageStride: number;
+  readonly pageCount: number;
+  private selectedPages;
+  private finalSelection?;
+  private fadeProgress;
+  private fadeKinds;
+  constructor(options: RadPagedSplatsOptions);
+  pageStart(slot: number): number;
+  /** Copies data; callers retain ownership of the packed buffers. */
+  writePage(slot: number, data: ReorderedSplatResult): void;
+  /** Remove the displayed cut when its scheduler becomes hidden. */
+  clearSelection(): boolean;
+  /** Snapshot only changed pools; never transfer live texture storage. */
+  snapshotSelection(ranges: RadSelectionRange[]): RadSelectionSnapshot;
+  /** Internal commit of worker-prepared data; the caller gives up the arrays. */
+  commitSelection(prepared: RadPreparedSelection): void;
+  /** Keep record indices, page occupancy and bounds on the same cut. */
+  private commitCut;
+  /** A normal streaming fade changes only two group coefficients. */
+  setFadeProgress(progress: number): boolean;
+  isPageSelected(slot: number): boolean;
+  /** Complete opacity changes without removing outgoing records. */
+  finishFadeIn(): boolean;
+  /** The worker already removed outgoing records from the final cut. */
+  finishFade(): boolean;
+  getByteLength(): number;
+  dispose(): void;
 }
 export {};

package/dist/types/data/SogRegionSplats.d.cts

@@ -1,26 +1,32 @@
-import { Box3 } from 'three';
-import { IndexedSplats } from './IndexedSplats.cjs';
-import { ReorderedSplatResult } from './defines.cjs';
+import type { Box3 } from "three";
+import { IndexedSplats } from "./IndexedSplats.cjs";
+import type { ReorderedSplatResult } from "./defines.cjs";
 export declare function sogBatchAllocationSize(count: number): number;
 export declare function sogBatchTextureLayout(count: number): {
-    capacity: number;
-    layerSize: number;
+  capacity: number;
+  layerSize: number;
 };
 /** Independently visible regions in fixed source slots. */
 export declare class SogRegionSplats extends IndexedSplats {
-    private readonly activeRanges;
-    private indicesDirty;
-    private boundsDirty;
-    private readonly regionBounds;
-    constructor(count: number, numSh: number);
-    write(start: number, data: ReorderedSplatResult): void;
-    setOpacity(start: number, count: number, opacity: number): {
+  private readonly activeRanges;
+  private indicesDirty;
+  private boundsDirty;
+  private readonly regionBounds;
+  constructor(count: number, numSh: number);
+  write(start: number, data: ReorderedSplatResult): void;
+  setOpacity(
+    start: number,
+    count: number,
+    opacity: number,
+  ):
+    | {
         visibilityChanged: boolean;
-    } | undefined;
-    /** The batch hides the region before releasing its slot. */
-    release(start: number): void;
-    getBoundingBox(centersOnly?: boolean, target?: Box3): Box3;
-    getByteLength(): number;
-    protected ensureIndices(): void;
-    dispose(): void;
+      }
+    | undefined;
+  /** The batch hides the region before releasing its slot. */
+  release(start: number): void;
+  getBoundingBox(centersOnly?: boolean, target?: Box3): Box3;
+  getByteLength(): number;
+  protected ensureIndices(): void;
+  dispose(): void;
 }

package/dist/types/data/SogRegionSplats.d.ts

@@ -1,26 +1,32 @@
-import { Box3 } from 'three';
-import { IndexedSplats } from './IndexedSplats';
-import { ReorderedSplatResult } from './defines';
+import type { Box3 } from "three";
+import { IndexedSplats } from "./IndexedSplats.js";
+import type { ReorderedSplatResult } from "./defines.js";
 export declare function sogBatchAllocationSize(count: number): number;
 export declare function sogBatchTextureLayout(count: number): {
-    capacity: number;
-    layerSize: number;
+  capacity: number;
+  layerSize: number;
 };
 /** Independently visible regions in fixed source slots. */
 export declare class SogRegionSplats extends IndexedSplats {
-    private readonly activeRanges;
-    private indicesDirty;
-    private boundsDirty;
-    private readonly regionBounds;
-    constructor(count: number, numSh: number);
-    write(start: number, data: ReorderedSplatResult): void;
-    setOpacity(start: number, count: number, opacity: number): {
+  private readonly activeRanges;
+  private indicesDirty;
+  private boundsDirty;
+  private readonly regionBounds;
+  constructor(count: number, numSh: number);
+  write(start: number, data: ReorderedSplatResult): void;
+  setOpacity(
+    start: number,
+    count: number,
+    opacity: number,
+  ):
+    | {
         visibilityChanged: boolean;
-    } | undefined;
-    /** The batch hides the region before releasing its slot. */
-    release(start: number): void;
-    getBoundingBox(centersOnly?: boolean, target?: Box3): Box3;
-    getByteLength(): number;
-    protected ensureIndices(): void;
-    dispose(): void;
+      }
+    | undefined;
+  /** The batch hides the region before releasing its slot. */
+  release(start: number): void;
+  getBoundingBox(centersOnly?: boolean, target?: Box3): Box3;
+  getByteLength(): number;
+  protected ensureIndices(): void;
+  dispose(): void;
 }

package/dist/types/data/SplatOpacityTable.d.cts

@@ -1,32 +1,32 @@
-import * as THREE from "three";
+import type * as THREE from "three";
 /** Source blocks hold group IDs; a small float32 table holds their opacities. */
 export declare class SplatOpacityTable {
-    private blocks;
-    private readonly blockSize;
-    private readonly blocksPerLayer;
-    private readonly blockTexture;
-    private dirtyLayers;
-    private dirty;
-    private values;
-    private valueTexture;
-    private valuesDirty;
-    private readonly ranges;
-    private readonly freeGroups;
-    private nextGroup;
-    constructor(capacity: number, layerSize: number, blockBits: number);
-    private createTexture;
-    private createValueTexture;
-    /** CPU arrays and GPU storage each occupy this many bytes. */
-    get byteLength(): number;
-    getOpacity(source: number): number;
-    setGroupOpacity(group: number, opacity: number): boolean;
-    private releaseBlock;
-    /** Validated ranges retain their group while only its coefficient changes. */
-    setOpacity(start: number, count: number, opacity: number): boolean;
-    copyBlocks(): Uint32Array<ArrayBuffer>;
-    /** Adopt a prepared RAD table, retaining any uploads still pending. */
-    commitBlocks(blocks: Uint32Array, dirtyLayers: Uint8Array): void;
-    get texture(): THREE.DataArrayTexture;
-    get opacityTexture(): THREE.DataArrayTexture;
-    dispose(): void;
+  private blocks;
+  private readonly blockSize;
+  private readonly blocksPerLayer;
+  private readonly blockTexture;
+  private dirtyLayers;
+  private dirty;
+  private values;
+  private valueTexture;
+  private valuesDirty;
+  private readonly ranges;
+  private readonly freeGroups;
+  private nextGroup;
+  constructor(capacity: number, layerSize: number, blockBits: number);
+  private createTexture;
+  private createValueTexture;
+  /** CPU arrays and GPU storage each occupy this many bytes. */
+  get byteLength(): number;
+  getOpacity(source: number): number;
+  setGroupOpacity(group: number, opacity: number): boolean;
+  private releaseBlock;
+  /** Validated ranges retain their group while only its coefficient changes. */
+  setOpacity(start: number, count: number, opacity: number): boolean;
+  copyBlocks(): Uint32Array<ArrayBuffer>;
+  /** Adopt a prepared RAD table, retaining any uploads still pending. */
+  commitBlocks(blocks: Uint32Array, dirtyLayers: Uint8Array): void;
+  get texture(): THREE.DataArrayTexture;
+  get opacityTexture(): THREE.DataArrayTexture;
+  dispose(): void;
 }