gaussian-splat-lite 1.2.2 → 1.3.1

package/dist/types/loaders/stream/rad-stream/RadStreamLoader.d.cts

@@ -1,53 +1,71 @@
-import { RadSource, RadSourceOptions } from '../../rad/RadSource.cjs';
-import { RadHeader, RadStreamChunk } from '../../rad/radFormat.cjs';
-import { RadSelectionRequest } from './RadSelectionState.cjs';
-import { prepareRadSelection } from './prepareRadSelection.cjs';
-import { RadStreamSelection } from './radFade.cjs';
-export type RadStreamLoaderOptions = Pick<RadSourceOptions, "url" | "file" | "fileBytes" | "resolveFile" | "manager" | "requestHeader" | "withCredentials">;
-/** Dedicated LOD traversal with a separate bounded pool of parallel decoders. */
+import type { RadSource, RadSourceOptions } from "../../rad/RadSource.cjs";
+import type { RadHeader, RadStreamChunk } from "../../rad/radFormat.cjs";
+import type { RadSelectionRequest } from "./RadSelectionState.cjs";
+import type {
+  RadSelectionPreparation,
+  prepareRadSelection,
+} from "./prepareRadSelection.cjs";
+import type { RadStreamSelection } from "./radFade.cjs";
+export type RadStreamLoaderOptions = Pick<
+  RadSourceOptions,
+  | "url"
+  | "file"
+  | "fileBytes"
+  | "resolveFile"
+  | "manager"
+  | "requestHeader"
+  | "withCredentials"
+>;
+/** Separate traversal and display preparation workers, plus bounded page decoders. */
 export declare class RadStreamLoader {
-    private readonly options;
-    readonly source: RadSource;
-    private readonly lodWorker;
-    private readonly pool;
-    private readonly decoderReady;
-    private readonly controller;
-    private initialization?;
-    private header?;
-    private rootReady?;
-    private initialRoot?;
-    private rootBytes?;
-    private pending;
-    private estimatedCodebookBytes;
-    private selectionBytes;
-    constructor(options: RadStreamLoaderOptions, maxConcurrentLoads?: number);
-    get stats(): {
-        cachedBytes: number;
-        downloadedBytes: number;
-        peakWasmMemoryBytes: number;
-        estimatedCodebookBytes: number;
-        bootstrapBytes: number;
-        selectionBytes: number;
-    };
-    get lodWorkerLost(): boolean;
-    private assertActive;
-    initialize(signal?: AbortSignal): Promise<RadHeader>;
-    loadChunk(index: number, signal?: AbortSignal, onDecoded?: () => void): Promise<RadStreamChunk>;
-    private loadChunkInternal;
-    private decode;
-    getChunkUrl(index: number): string;
-    selectLod(request: RadSelectionRequest): Promise<RadStreamSelection>;
-    prepareSelection(request: Parameters<typeof prepareRadSelection>[0]): Promise<{
-        selection: {
-            indices: Uint32Array;
-            wantedChunks: Uint32Array;
-            touchedChunks: Uint32Array;
-            selectionId: number;
-            changedChunks: Uint32Array;
-        };
-        fade: boolean;
-        pools: import('../../../data/RadPagedSplats.cjs').RadPreparedSelection[];
-    }>;
-    releaseChunk(index: number, generation?: number): void;
-    dispose(): void;
+  private readonly options;
+  private readonly onRegistrationSettled;
+  readonly source: RadSource;
+  private readonly lodWorker;
+  private readonly preparationWorker;
+  private readonly pool;
+  private readonly decoderReady;
+  private readonly controller;
+  private initialization?;
+  private header?;
+  private rootReady?;
+  private initialRoot?;
+  private rootBytes?;
+  private pending;
+  readonly pendingRegistrationBytes: number;
+  private estimatedCodebookBytes;
+  private selectionBytes;
+  private preparationBytes;
+  constructor(
+    options: RadStreamLoaderOptions,
+    maxConcurrentLoads: number,
+    onRegistrationSettled: () => void,
+  );
+  get stats(): {
+    cachedBytes: number;
+    downloadedBytes: number;
+    peakWasmMemoryBytes: number;
+    estimatedCodebookBytes: number;
+    bootstrapBytes: number;
+    selectionBytes: number;
+  };
+  /** Reserve the source cache and codebooks for all decoder workers. */
+  get residentCpuOverheadBytes(): number;
+  get selectionWorkerLost(): boolean;
+  private assertActive;
+  initialize(signal?: AbortSignal): Promise<RadHeader>;
+  loadChunk(
+    index: number,
+    signal?: AbortSignal,
+  ): Promise<{ data: RadStreamChunk; registration: Promise<void> }>;
+  private loadChunkInternal;
+  private decode;
+  private registerChunk;
+  getChunkUrl(index: number): string;
+  selectLod(request: RadSelectionRequest): Promise<RadStreamSelection>;
+  prepareSelection(
+    request: Parameters<typeof prepareRadSelection>[0],
+  ): Promise<RadSelectionPreparation>;
+  releaseChunk(index: number, generation?: number): void;
+  dispose(): void;
 }

package/dist/types/loaders/stream/rad-stream/RadStreamLoader.d.ts

@@ -1,53 +1,71 @@
-import { RadSource, RadSourceOptions } from '../../rad/RadSource';
-import { RadHeader, RadStreamChunk } from '../../rad/radFormat';
-import { RadSelectionRequest } from './RadSelectionState';
-import { prepareRadSelection } from './prepareRadSelection';
-import { RadStreamSelection } from './radFade';
-export type RadStreamLoaderOptions = Pick<RadSourceOptions, "url" | "file" | "fileBytes" | "resolveFile" | "manager" | "requestHeader" | "withCredentials">;
-/** Dedicated LOD traversal with a separate bounded pool of parallel decoders. */
+import type { RadSource, RadSourceOptions } from "../../rad/RadSource.js";
+import type { RadHeader, RadStreamChunk } from "../../rad/radFormat.js";
+import type { RadSelectionRequest } from "./RadSelectionState.js";
+import type {
+  RadSelectionPreparation,
+  prepareRadSelection,
+} from "./prepareRadSelection.js";
+import type { RadStreamSelection } from "./radFade.js";
+export type RadStreamLoaderOptions = Pick<
+  RadSourceOptions,
+  | "url"
+  | "file"
+  | "fileBytes"
+  | "resolveFile"
+  | "manager"
+  | "requestHeader"
+  | "withCredentials"
+>;
+/** Separate traversal and display preparation workers, plus bounded page decoders. */
 export declare class RadStreamLoader {
-    private readonly options;
-    readonly source: RadSource;
-    private readonly lodWorker;
-    private readonly pool;
-    private readonly decoderReady;
-    private readonly controller;
-    private initialization?;
-    private header?;
-    private rootReady?;
-    private initialRoot?;
-    private rootBytes?;
-    private pending;
-    private estimatedCodebookBytes;
-    private selectionBytes;
-    constructor(options: RadStreamLoaderOptions, maxConcurrentLoads?: number);
-    get stats(): {
-        cachedBytes: number;
-        downloadedBytes: number;
-        peakWasmMemoryBytes: number;
-        estimatedCodebookBytes: number;
-        bootstrapBytes: number;
-        selectionBytes: number;
-    };
-    get lodWorkerLost(): boolean;
-    private assertActive;
-    initialize(signal?: AbortSignal): Promise<RadHeader>;
-    loadChunk(index: number, signal?: AbortSignal, onDecoded?: () => void): Promise<RadStreamChunk>;
-    private loadChunkInternal;
-    private decode;
-    getChunkUrl(index: number): string;
-    selectLod(request: RadSelectionRequest): Promise<RadStreamSelection>;
-    prepareSelection(request: Parameters<typeof prepareRadSelection>[0]): Promise<{
-        selection: {
-            indices: Uint32Array;
-            wantedChunks: Uint32Array;
-            touchedChunks: Uint32Array;
-            selectionId: number;
-            changedChunks: Uint32Array;
-        };
-        fade: boolean;
-        pools: import('../../../data/RadPagedSplats').RadPreparedSelection[];
-    }>;
-    releaseChunk(index: number, generation?: number): void;
-    dispose(): void;
+  private readonly options;
+  private readonly onRegistrationSettled;
+  readonly source: RadSource;
+  private readonly lodWorker;
+  private readonly preparationWorker;
+  private readonly pool;
+  private readonly decoderReady;
+  private readonly controller;
+  private initialization?;
+  private header?;
+  private rootReady?;
+  private initialRoot?;
+  private rootBytes?;
+  private pending;
+  readonly pendingRegistrationBytes: number;
+  private estimatedCodebookBytes;
+  private selectionBytes;
+  private preparationBytes;
+  constructor(
+    options: RadStreamLoaderOptions,
+    maxConcurrentLoads: number,
+    onRegistrationSettled: () => void,
+  );
+  get stats(): {
+    cachedBytes: number;
+    downloadedBytes: number;
+    peakWasmMemoryBytes: number;
+    estimatedCodebookBytes: number;
+    bootstrapBytes: number;
+    selectionBytes: number;
+  };
+  /** Reserve the source cache and codebooks for all decoder workers. */
+  get residentCpuOverheadBytes(): number;
+  get selectionWorkerLost(): boolean;
+  private assertActive;
+  initialize(signal?: AbortSignal): Promise<RadHeader>;
+  loadChunk(
+    index: number,
+    signal?: AbortSignal,
+  ): Promise<{ data: RadStreamChunk; registration: Promise<void> }>;
+  private loadChunkInternal;
+  private decode;
+  private registerChunk;
+  getChunkUrl(index: number): string;
+  selectLod(request: RadSelectionRequest): Promise<RadStreamSelection>;
+  prepareSelection(
+    request: Parameters<typeof prepareRadSelection>[0],
+  ): Promise<RadSelectionPreparation>;
+  releaseChunk(index: number, generation?: number): void;
+  dispose(): void;
 }

package/dist/types/loaders/stream/rad-stream/RadStreamScheduler.d.cts

@@ -1,107 +1,131 @@
-import { StreamResolutionSource } from '../StreamCameras.cjs';
-import { StreamSchedulerOptions, StreamStats } from '../streamOptions.cjs';
-import { RadStreamLoaderOptions } from './RadStreamLoader.cjs';
-import * as THREE from "three";
-export type RadStreamSchedulerOptions = RadStreamLoaderOptions & StreamSchedulerOptions;
+import type * as THREE from "three";
+import type { StreamResolutionSource } from "../StreamCameras.cjs";
+import type { StreamSchedulerOptions, StreamStats } from "../streamOptions.cjs";
+import type { RadStreamLoaderOptions } from "./RadStreamLoader.cjs";
+export type RadStreamSchedulerOptions = RadStreamLoaderOptions &
+  StreamSchedulerOptions & {
+    /** Allowed fractional splat budget overshoot. Default: 0.1; 0 forbids overshoot. */
+    splatBudgetTolerance?: number;
+    /** Retained CPU byte budget, excluding pending copies and WASM. Default: 2 GiB. */
+    maxResidentCpuBytes?: number;
+    /** Estimated GPU byte budget for resident streaming data. Default: 1 GiB. */
+    maxResidentGpuBytes?: number;
+  };
 export type RadStreamStats = StreamStats & {
-    pageBudget: number;
-    lodTimeMs: number;
+  /** Resident page limit derived from the smaller CPU/GPU allowance. */
+  pageBudget: number;
+  lodTimeMs: number;
 };
 /** Camera-driven RAD tree cuts with crossfades, on-demand pages and cooldown. */
 export declare class RadStreamScheduler {
-    private readonly options;
-    readonly group: THREE.Group;
-    readonly initialized: Promise<this>;
-    readonly firstRenderable: Promise<this>;
-    readonly cooldownMs: number;
-    readonly fadeDurationMs: number;
-    readonly maxConcurrentLoads: number;
-    private _splatBudget;
-    private readonly loader;
-    private readonly abort;
-    private readonly streamCameras;
-    private readonly pages;
-    private readonly pools;
-    private readonly bounds;
-    private readonly matrix;
-    private meta?;
-    private pageSize;
-    private pageBudget;
-    private numSh;
-    private maxPagePendingBytes;
-    private disposed;
-    private shown;
-    private displayed?;
-    private ready?;
-    private traversal?;
-    private preparation?;
-    private wanted;
-    private revision;
-    private lastRequestedRevision;
-    private refinementStopped;
-    private lastViewKey;
-    private views;
-    private lodTimeMs;
-    private resolveFirst;
-    private rejectFirst;
-    constructor(options: RadStreamSchedulerOptions);
-    /** Selected-node budget. Assigning a new value requests LOD selection. */
-    get splatBudget(): number;
-    set splatBudget(value: number);
-    /** Cameras that select detail, in registration order. */
-    get cameras(): readonly THREE.Camera[];
-    hasCamera(camera: THREE.Camera): boolean;
-    /**
-     * Select detail for this camera on each update; set its resolution too. For
-     * WebXR register renderer.xr.getCamera(): it selects with its eyes' combined
-     * frustum, sized by an eye's viewport. Returns whether the camera was newly
-     * added.
-     */
-    setCamera(camera: THREE.Camera): boolean;
-    /** Stop selecting detail for this camera. Returns whether it was registered. */
-    deleteCamera(camera: THREE.Camera): boolean;
-    /**
-     * Set a registered camera's render size in CSS pixels, without the device
-     * pixel ratio. Returns whether the camera is registered.
-     */
-    setResolution(camera: THREE.Camera, xOrVec: number | THREE.Vector2, y?: number): boolean;
-    /** Set a registered camera's resolution from renderer.getSize(). */
-    setResolutionFromRenderer(camera: THREE.Camera, renderer: StreamResolutionSource): boolean;
-    get stats(): RadStreamStats;
-    /** Group-local root bounds plus selected Gaussian extents; approximate while streaming. */
-    getBoundingBox(): THREE.Box3;
-    private initialize;
-    /**
-     * Call before rendering. Registered cameras share one cut at the greatest
-     * detail any of them needs.
-     */
-    update(): boolean;
-    private requestSelection;
-    private selectionPagesReady;
-    private prepareSelection;
-    private applySelection;
-    private invalidatePendingSelection;
-    private clearSelectionState;
-    /** Worker snapshots and waiting cuts pin pages without renewing cooldown. */
-    private isPagePinned;
-    private cancelUnusedLoads;
-    private updateFade;
-    private page;
-    private pump;
-    private loadPage;
-    private setInitialBounds;
-    private findSlot;
-    private reservePages;
-    private uploadPages;
-    private releasePage;
-    private releaseUnused;
-    /** Map a raycast hit's rendered index back to its stable file index. */
-    getGlobalIndex(mesh: THREE.Object3D, renderedIndex: number): number;
-    private changed;
-    private failed;
-    private stopRefinement;
-    private scheduleRetry;
-    private retryDeadlines;
-    private readonly retryTimer;
-    dispose(): void;
+  private readonly options;
+  readonly group: THREE.Group;
+  readonly initialized: Promise<this>;
+  readonly firstRenderable: Promise<this>;
+  readonly cooldownMs: number;
+  readonly fadeDurationMs: number;
+  readonly maxConcurrentLoads: number;
+  readonly maxResidentCpuBytes: number;
+  readonly maxResidentGpuBytes: number;
+  private _splatBudget;
+  private _splatBudgetTolerance;
+  private readonly loader;
+  private readonly abort;
+  private readonly streamCameras;
+  private readonly pages;
+  private readonly pools;
+  private readonly bounds;
+  private readonly matrix;
+  private meta?;
+  private pageSize;
+  private pageBudget;
+  private numSh;
+  private maxPagePendingBytes;
+  private disposed;
+  private shown;
+  private displayed?;
+  private ready?;
+  private traversal?;
+  private preparation?;
+  private wanted;
+  private revision;
+  private lastRequestedRevision;
+  private refinementStopped;
+  private lastViewKey;
+  private views;
+  private lodTimeMs;
+  private resolveFirst;
+  private rejectFirst;
+  constructor(options: RadStreamSchedulerOptions);
+  /** Target selected-node budget. Assigning a new value requests LOD selection. */
+  get splatBudget(): number;
+  set splatBudget(value: number);
+  /** Allowed fractional budget overshoot; zero forbids overshoot. */
+  get splatBudgetTolerance(): number;
+  set splatBudgetTolerance(value: number);
+  /** Cameras that select detail, in registration order. */
+  get cameras(): readonly THREE.Camera[];
+  hasCamera(camera: THREE.Camera): boolean;
+  /**
+   * Select detail for this camera on each update; set its resolution too. For
+   * WebXR register renderer.xr.getCamera(): it selects with its eyes' combined
+   * frustum, sized by an eye's viewport. Returns whether the camera was newly
+   * added.
+   */
+  setCamera(camera: THREE.Camera): boolean;
+  /** Stop selecting detail for this camera. Returns whether it was registered. */
+  deleteCamera(camera: THREE.Camera): boolean;
+  /**
+   * Set a registered camera's render size in CSS pixels, without the device
+   * pixel ratio. Returns whether the camera is registered.
+   */
+  setResolution(
+    camera: THREE.Camera,
+    xOrVec: number | THREE.Vector2,
+    y?: number,
+  ): boolean;
+  /** Set a registered camera's resolution from renderer.getSize(). */
+  setResolutionFromRenderer(
+    camera: THREE.Camera,
+    renderer: StreamResolutionSource,
+  ): boolean;
+  get stats(): RadStreamStats;
+  /** Group-local root bounds plus selected Gaussian extents; approximate while streaming. */
+  getBoundingBox(): THREE.Box3;
+  private initialize;
+  /**
+   * Call before rendering. Registered cameras share one cut at the greatest
+   * detail any of them needs.
+   */
+  update(): boolean;
+  private get selectionBaselineId();
+  private requestSelection;
+  private selectionPagesReady;
+  private prepareSelection;
+  private applySelection;
+  private invalidatePendingSelection;
+  private clearSelectionState;
+  /** Worker snapshots and waiting cuts pin pages without renewing cooldown. */
+  private isPagePinned;
+  private cancelUnusedLoads;
+  private updateFade;
+  private page;
+  private pump;
+  private loadPage;
+  private setInitialBounds;
+  private findSlot;
+  private reservePages;
+  private uploadPages;
+  private releasePage;
+  private isPageRequired;
+  private releaseUnused;
+  /** Map a raycast hit's rendered index back to its stable file index. */
+  getGlobalIndex(mesh: THREE.Object3D, renderedIndex: number): number;
+  private changed;
+  private failed;
+  private stopRefinement;
+  private scheduleRetry;
+  private retryDeadlines;
+  private readonly retryTimer;
+  dispose(): void;
 }