gaussian-splat-lite 1.2.2 → 1.3.1

package/dist/types/loaders/stream/sog-stream/sogLod.d.ts

@@ -1,70 +1,91 @@
-import { Box3 } from 'three';
+import type { Box3 } from "three";
 export type SogLodRange = {
-    leaf: number;
-    level: number;
-    /** -1 for an empty LOD, which has no backing file. */
-    file: number;
-    offset: number;
-    count: number;
+  leaf: number;
+  level: number;
+  /** -1 for an empty LOD, which has no backing file. */
+  file: number;
+  offset: number;
+  count: number;
 };
 export type SogLodLeaf = {
-    id: number;
-    /** Coarse to fine, with strictly increasing counts and decreasing levels. */
-    lods: SogLodRange[];
+  id: number;
+  /** Coarse to fine, with strictly decreasing levels. */
+  lods: SogLodRange[];
 };
 export type SogLodNode = {
-    bound: Box3;
-    children?: SogLodNode[];
-    leaf?: SogLodLeaf;
+  bound: Box3;
+  children?: SogLodNode[];
+  leaf?: SogLodLeaf;
 };
 export type SogLodFile = {
-    url: string;
-    count: number;
-    ranges: SogLodRange[];
+  url: string;
+  count: number;
+  ranges: SogLodRange[];
 };
 export type SogLodManifest = {
-    tree: SogLodNode;
-    leaves: SogLodLeaf[];
-    /** Flattened in leaf/LOD order; each leaf's first entry is unused. */
-    upgradeRatios: number[];
-    files: SogLodFile[];
-    environment?: string;
+  tree: SogLodNode;
+  leaves: SogLodLeaf[];
+  lodLevels: number;
+  files: SogLodFile[];
+  environment?: string;
 };
 export declare const SOG_LOD_STRIDE = 4;
 /** Packed worker index. Float64 preserves source bounds and safe-integer counts. */
 export type SogLodIndex = {
-    /** Preorder nodes: min XYZ, max XYZ, next index after the subtree, leaf ID (-1 for interiors). */
-    nodes: Float64Array;
-    leafOffsets: Uint32Array;
-    /** Per level: level, file, offset, count. */
-    lods: Float64Array;
-    /** Best reachable distance-error reduction per added splat, in LOD order. */
-    upgradeRatios: Float32Array;
-    urls: string[];
-    counts: Float64Array;
-    environment?: string;
+  /** Preorder nodes: min XYZ, max XYZ, next index after the subtree, leaf ID (-1 for interiors). */
+  nodes: Float64Array;
+  leafOffsets: Uint32Array;
+  /** Per level: level, file, offset, count. */
+  lods: Float64Array;
+  lodLevels: number;
+  urls: string[];
+  counts: Float64Array;
+  environment?: string;
 };
 /** Scheduler metadata; the complete spatial tree stays in the LOD worker. */
-export type SogLodMetadata = Omit<SogLodIndex, "nodes" | "upgradeRatios"> & {
-    /** Root min XYZ and max XYZ. */
-    bounds: Float64Array;
+export type SogLodMetadata = Omit<SogLodIndex, "nodes" | "lodLevels"> & {
+  /** Root min XYZ and max XYZ. */
+  bounds: Float64Array;
 };
 /** Flatten the tree and ranges into transferable typed arrays. */
 export declare function packSogLodIndex(manifest: SogLodManifest): SogLodIndex;
 /** Materialize only leaves visited by the camera, preserving stable range identities. */
-export declare function readSogLodLeaf(index: Pick<SogLodIndex, "leafOffsets" | "lods">, id: number): SogLodLeaf;
+export declare function readSogLodLeaf(
+  index: Pick<SogLodIndex, "leafOffsets" | "lods">,
+  id: number,
+): SogLodLeaf;
 /** Streamed SOG v1, including the earlier unversioned manifests. */
-export declare function parseSogLodManifest(value: unknown, baseUrl: string): SogLodManifest;
+export declare function parseSogLodManifest(
+  value: unknown,
+  baseUrl: string,
+): SogLodManifest;
 export type SogVisibleLeaf = {
-    leaf: SogLodLeaf;
-    weight: number;
+  leaf: SogLodLeaf;
+  /** World-space distance to the region, compensated for the camera's field of view. */
+  distance: number;
+};
+export type SogBudgetMode = "target" | "limit";
+export type SogLodOptions = {
+  budget: number;
+  splatBudgetMode: SogBudgetMode;
+  lodBaseDistance: number;
+  lodMultiplier: number;
 };
 /** Reuse cached refinements up to the target, then split gaps of four or more. */
-export declare function resolveSogLod(leaf: SogLodLeaf, target: SogLodRange, current: SogLodRange | undefined, isLoaded: (range: SogLodRange) => boolean): {
-    range: SogLodRange | undefined;
-    load?: SogLodRange;
-    /** Wait until range is attached before requesting the next LOD. */
-    refinement?: boolean;
+export declare function resolveSogLod(
+  leaf: SogLodLeaf,
+  target: SogLodRange,
+  current: SogLodRange | undefined,
+  isLoaded: (range: SogLodRange) => boolean,
+): {
+  range: SogLodRange | undefined;
+  load?: SogLodRange;
+  /** Wait until range is attached before requesting the next LOD. */
+  refinement?: boolean;
 };
-/** Distance bands within a splat budget, using a small heap. */
-export declare function selectSogLods(visible: SogVisibleLeaf[], budget: number, manifest: Pick<SogLodIndex, "leafOffsets" | "upgradeRatios">): Map<number, SogLodRange>;
+/** Select distance bands, fitting their common base distance to the splat budget. */
+export declare function selectSogLods(
+  visible: SogVisibleLeaf[],
+  lodLevels: number,
+  options: SogLodOptions,
+): Map<number, SogLodRange>;

package/dist/types/loaders/stream/sog-stream/sogVisibility.d.cts

@@ -1,35 +1,41 @@
-import { SogLodIndex } from './sogLod.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { SogLodIndex, SogLodOptions } from "./sogLod.cjs";
 export type SogCamera = {
-    modelView: number[];
-    projection: number[];
-    coordinateSystem: THREE.CoordinateSystem;
-    reversedDepth: boolean;
+  modelView: number[];
+  projection: number[];
+  coordinateSystem: THREE.CoordinateSystem;
+  reversedDepth: boolean;
 };
 export type SogView = {
-    /** The registered cameras that see the group; selection serves all of them. */
-    cameras: SogCamera[];
-    shown: boolean;
+  /** The registered cameras that see the group; selection serves all of them. */
+  cameras: SogCamera[];
+  shown: boolean;
 };
+export type SogLodRequest = SogLodOptions & { view: SogView };
 /**
  * Capture the cameras that see the group without traversing the manifest or
  * reducing matrix precision. WebXR selects detail from each eye's current pose and frustum.
  */
-export declare function captureSogView(cameras: readonly THREE.Camera[], group: THREE.Object3D): SogView;
+export declare function captureSogView(
+  cameras: readonly THREE.Camera[],
+  group: THREE.Object3D,
+): SogView;
 /** Stable key of a view, for skipping unchanged selection requests. */
 export declare function getSogViewKey(view: SogView): string;
 /** Worker traversal state keeps leaf identities stable between selections. */
 export declare class SogVisibility {
-    private readonly manifest;
-    private readonly leaves;
-    private readonly cameras;
-    private readonly clip;
-    private readonly bound;
-    private readonly closest;
-    private readonly inverseModelView;
-    constructor(manifest: Pick<SogLodIndex, "nodes" | "leafOffsets" | "lods" | "upgradeRatios">);
-    private prepareCameras;
-    private collect;
-    /** Transfer only [leaf ID, LOD ordinal] pairs in loading priority order. */
-    select(view: SogView, budget: number): Uint32Array;
+  private readonly manifest;
+  private readonly leaves;
+  private readonly cameras;
+  private readonly clip;
+  private readonly bound;
+  private readonly closest;
+  private readonly inverseModelView;
+  constructor(
+    manifest: Pick<SogLodIndex, "nodes" | "leafOffsets" | "lods" | "lodLevels">,
+  );
+  private prepareCameras;
+  private collect;
+  /** Transfer only [leaf ID, LOD ordinal] pairs in loading priority order. */
+  select(request: SogLodRequest): Uint32Array;
 }

package/dist/types/loaders/stream/sog-stream/sogVisibility.d.ts

@@ -1,35 +1,41 @@
-import { SogLodIndex } from './sogLod';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { SogLodIndex, SogLodOptions } from "./sogLod.js";
 export type SogCamera = {
-    modelView: number[];
-    projection: number[];
-    coordinateSystem: THREE.CoordinateSystem;
-    reversedDepth: boolean;
+  modelView: number[];
+  projection: number[];
+  coordinateSystem: THREE.CoordinateSystem;
+  reversedDepth: boolean;
 };
 export type SogView = {
-    /** The registered cameras that see the group; selection serves all of them. */
-    cameras: SogCamera[];
-    shown: boolean;
+  /** The registered cameras that see the group; selection serves all of them. */
+  cameras: SogCamera[];
+  shown: boolean;
 };
+export type SogLodRequest = SogLodOptions & { view: SogView };
 /**
  * Capture the cameras that see the group without traversing the manifest or
  * reducing matrix precision. WebXR selects detail from each eye's current pose and frustum.
  */
-export declare function captureSogView(cameras: readonly THREE.Camera[], group: THREE.Object3D): SogView;
+export declare function captureSogView(
+  cameras: readonly THREE.Camera[],
+  group: THREE.Object3D,
+): SogView;
 /** Stable key of a view, for skipping unchanged selection requests. */
 export declare function getSogViewKey(view: SogView): string;
 /** Worker traversal state keeps leaf identities stable between selections. */
 export declare class SogVisibility {
-    private readonly manifest;
-    private readonly leaves;
-    private readonly cameras;
-    private readonly clip;
-    private readonly bound;
-    private readonly closest;
-    private readonly inverseModelView;
-    constructor(manifest: Pick<SogLodIndex, "nodes" | "leafOffsets" | "lods" | "upgradeRatios">);
-    private prepareCameras;
-    private collect;
-    /** Transfer only [leaf ID, LOD ordinal] pairs in loading priority order. */
-    select(view: SogView, budget: number): Uint32Array;
+  private readonly manifest;
+  private readonly leaves;
+  private readonly cameras;
+  private readonly clip;
+  private readonly bound;
+  private readonly closest;
+  private readonly inverseModelView;
+  constructor(
+    manifest: Pick<SogLodIndex, "nodes" | "leafOffsets" | "lods" | "lodLevels">,
+  );
+  private prepareCameras;
+  private collect;
+  /** Transfer only [leaf ID, LOD ordinal] pairs in loading priority order. */
+  select(request: SogLodRequest): Uint32Array;
 }

package/dist/types/loaders/stream/sog-stream/worker.d.cts

@@ -1,41 +1,8 @@
-import { resolveAsset } from '../../workerDecode.cjs';
-declare const rpcHandlers: {
-    resolveAsset: typeof resolveAsset;
-    loadSogChunk: ({ id, ...args }: import('../../loadTypes.cjs').SplatLoadArgs & {
-        id: number;
-    }, options: {
-        sendStatus: (data: import('../../loadTypes.cjs').SplatLoadStatus) => void;
-    }) => Promise<import('./workerHandlers.cjs').SogChunkInfo>;
-    cacheSogChunk: ({ id, data, }: {
-        id: number;
-        data: import('../../../data/defines.cjs').SplatResult;
-    }) => import('./workerHandlers.cjs').SogChunkInfo;
-    extractSogRegions: ({ id, ranges, }: {
-        id: number;
-        ranges: {
-            start: number;
-            count: number;
-        }[];
-    }) => import('../../../data/defines.cjs').ReorderedSplatResult[];
-    releaseSogChunk: ({ id }: {
-        id: number;
-    }) => void;
-    parseSogIndex: ({ bytes, baseUrl, }: {
-        bytes: ArrayBuffer;
-        baseUrl: string;
-    }) => {
-        bounds: Float64Array<ArrayBuffer>;
-        leafOffsets: Uint32Array<ArrayBuffer>;
-        lods: Float64Array<ArrayBuffer>;
-        retainedIndexBytes: number;
-        urls: string[];
-        counts: Float64Array;
-        environment?: string;
-    };
-    selectSogLod: ({ view, budget }: {
-        view: import('./sogVisibility.cjs').SogView;
-        budget: number;
-    }) => Uint32Array<ArrayBufferLike>;
+import type { resolveAsset } from "../../workerDecode.cjs";
+import type { createSogStreamHandlers } from "./workerHandlers.cjs";
+
+export type SogStreamRpcHandlers = ReturnType<
+  typeof createSogStreamHandlers
+> & {
+  resolveAsset: typeof resolveAsset;
 };
-export type SogStreamRpcHandlers = typeof rpcHandlers;
-export {};

package/dist/types/loaders/stream/sog-stream/worker.d.ts

@@ -1,41 +1,8 @@
-import { resolveAsset } from '../../workerDecode';
-declare const rpcHandlers: {
-    resolveAsset: typeof resolveAsset;
-    loadSogChunk: ({ id, ...args }: import('../../loadTypes').SplatLoadArgs & {
-        id: number;
-    }, options: {
-        sendStatus: (data: import('../../loadTypes').SplatLoadStatus) => void;
-    }) => Promise<import('./workerHandlers').SogChunkInfo>;
-    cacheSogChunk: ({ id, data, }: {
-        id: number;
-        data: import('../../../data/defines').SplatResult;
-    }) => import('./workerHandlers').SogChunkInfo;
-    extractSogRegions: ({ id, ranges, }: {
-        id: number;
-        ranges: {
-            start: number;
-            count: number;
-        }[];
-    }) => import('../../../data/defines').ReorderedSplatResult[];
-    releaseSogChunk: ({ id }: {
-        id: number;
-    }) => void;
-    parseSogIndex: ({ bytes, baseUrl, }: {
-        bytes: ArrayBuffer;
-        baseUrl: string;
-    }) => {
-        bounds: Float64Array<ArrayBuffer>;
-        leafOffsets: Uint32Array<ArrayBuffer>;
-        lods: Float64Array<ArrayBuffer>;
-        retainedIndexBytes: number;
-        urls: string[];
-        counts: Float64Array;
-        environment?: string;
-    };
-    selectSogLod: ({ view, budget }: {
-        view: import('./sogVisibility').SogView;
-        budget: number;
-    }) => Uint32Array<ArrayBufferLike>;
+import type { resolveAsset } from "../../workerDecode.js";
+import type { createSogStreamHandlers } from "./workerHandlers.js";
+
+export type SogStreamRpcHandlers = ReturnType<
+  typeof createSogStreamHandlers
+> & {
+  resolveAsset: typeof resolveAsset;
 };
-export type SogStreamRpcHandlers = typeof rpcHandlers;
-export {};

package/dist/types/loaders/stream/sog-stream/workerHandlers.d.cts

@@ -1,48 +1,67 @@
-import { SplatResult } from '../../../data/defines.cjs';
-import { SplatLoadArgs, SplatLoadStatus } from '../../loadTypes.cjs';
-import { SogView } from './sogVisibility.cjs';
+import type { SplatResult } from "../../../data/defines.cjs";
+import type { SplatLoadArgs, SplatLoadStatus } from "../../loadTypes.cjs";
+import type { SogLodRequest } from "./sogVisibility.cjs";
 export type SogChunkInfo = {
-    numSplats: number;
-    numSh: number;
-    byteLength: number;
+  numSplats: number;
+  numSh: number;
+  byteLength: number;
 };
 /** LOD workers parse the index once before selection; other workers own chunk caches. */
-export declare function createSogStreamHandlers(decodeSplats: (args: SplatLoadArgs, options: {
-    sendStatus: (data: SplatLoadStatus) => void;
-}) => Promise<SplatResult>): {
-    loadSogChunk: ({ id, ...args }: SplatLoadArgs & {
-        id: number;
-    }, options: {
-        sendStatus: (data: SplatLoadStatus) => void;
-    }) => Promise<SogChunkInfo>;
-    cacheSogChunk: ({ id, data, }: {
-        id: number;
-        data: SplatResult;
-    }) => SogChunkInfo;
-    extractSogRegions: ({ id, ranges, }: {
-        id: number;
-        ranges: {
-            start: number;
-            count: number;
-        }[];
-    }) => import('../../../data/defines.cjs').ReorderedSplatResult[];
-    releaseSogChunk: ({ id }: {
-        id: number;
-    }) => void;
-    parseSogIndex: ({ bytes, baseUrl, }: {
-        bytes: ArrayBuffer;
-        baseUrl: string;
-    }) => {
-        bounds: Float64Array<ArrayBuffer>;
-        leafOffsets: Uint32Array<ArrayBuffer>;
-        lods: Float64Array<ArrayBuffer>;
-        retainedIndexBytes: number;
-        urls: string[];
-        counts: Float64Array;
-        environment?: string;
-    };
-    selectSogLod: ({ view, budget }: {
-        view: SogView;
-        budget: number;
-    }) => Uint32Array<ArrayBufferLike>;
+export declare function createSogStreamHandlers(
+  decodeSplats: (
+    args: SplatLoadArgs,
+    options: {
+      sendStatus: (data: SplatLoadStatus) => void;
+    },
+  ) => Promise<SplatResult>,
+): {
+  loadSogChunk: (
+    {
+      id,
+      ...args
+    }: SplatLoadArgs & {
+      id: number;
+    },
+    options: {
+      sendStatus: (data: SplatLoadStatus) => void;
+    },
+  ) => Promise<SogChunkInfo>;
+  cacheSogChunk: ({
+    id,
+    data,
+  }: {
+    id: number;
+    data: SplatResult;
+  }) => SogChunkInfo;
+  extractSogRegions: ({
+    id,
+    ranges,
+  }: {
+    id: number;
+    ranges: {
+      start: number;
+      count: number;
+    }[];
+  }) => import("../../../data/defines.cjs").ReorderedSplatResult[];
+  releaseSogChunk: ({
+    id,
+  }: {
+    id: number;
+  }) => void;
+  parseSogIndex: ({
+    bytes,
+    baseUrl,
+  }: {
+    bytes: ArrayBuffer;
+    baseUrl: string;
+  }) => {
+    bounds: Float64Array<ArrayBuffer>;
+    leafOffsets: Uint32Array<ArrayBuffer>;
+    lods: Float64Array<ArrayBuffer>;
+    retainedIndexBytes: number;
+    urls: string[];
+    counts: Float64Array;
+    environment?: string;
+  };
+  selectSogLod: (request: SogLodRequest) => Uint32Array<ArrayBufferLike>;
 };

package/dist/types/loaders/stream/sog-stream/workerHandlers.d.ts

@@ -1,48 +1,67 @@
-import { SplatResult } from '../../../data/defines';
-import { SplatLoadArgs, SplatLoadStatus } from '../../loadTypes';
-import { SogView } from './sogVisibility';
+import type { SplatResult } from "../../../data/defines.js";
+import type { SplatLoadArgs, SplatLoadStatus } from "../../loadTypes.js";
+import type { SogLodRequest } from "./sogVisibility.js";
 export type SogChunkInfo = {
-    numSplats: number;
-    numSh: number;
-    byteLength: number;
+  numSplats: number;
+  numSh: number;
+  byteLength: number;
 };
 /** LOD workers parse the index once before selection; other workers own chunk caches. */
-export declare function createSogStreamHandlers(decodeSplats: (args: SplatLoadArgs, options: {
-    sendStatus: (data: SplatLoadStatus) => void;
-}) => Promise<SplatResult>): {
-    loadSogChunk: ({ id, ...args }: SplatLoadArgs & {
-        id: number;
-    }, options: {
-        sendStatus: (data: SplatLoadStatus) => void;
-    }) => Promise<SogChunkInfo>;
-    cacheSogChunk: ({ id, data, }: {
-        id: number;
-        data: SplatResult;
-    }) => SogChunkInfo;
-    extractSogRegions: ({ id, ranges, }: {
-        id: number;
-        ranges: {
-            start: number;
-            count: number;
-        }[];
-    }) => import('../../../data/defines').ReorderedSplatResult[];
-    releaseSogChunk: ({ id }: {
-        id: number;
-    }) => void;
-    parseSogIndex: ({ bytes, baseUrl, }: {
-        bytes: ArrayBuffer;
-        baseUrl: string;
-    }) => {
-        bounds: Float64Array<ArrayBuffer>;
-        leafOffsets: Uint32Array<ArrayBuffer>;
-        lods: Float64Array<ArrayBuffer>;
-        retainedIndexBytes: number;
-        urls: string[];
-        counts: Float64Array;
-        environment?: string;
-    };
-    selectSogLod: ({ view, budget }: {
-        view: SogView;
-        budget: number;
-    }) => Uint32Array<ArrayBufferLike>;
+export declare function createSogStreamHandlers(
+  decodeSplats: (
+    args: SplatLoadArgs,
+    options: {
+      sendStatus: (data: SplatLoadStatus) => void;
+    },
+  ) => Promise<SplatResult>,
+): {
+  loadSogChunk: (
+    {
+      id,
+      ...args
+    }: SplatLoadArgs & {
+      id: number;
+    },
+    options: {
+      sendStatus: (data: SplatLoadStatus) => void;
+    },
+  ) => Promise<SogChunkInfo>;
+  cacheSogChunk: ({
+    id,
+    data,
+  }: {
+    id: number;
+    data: SplatResult;
+  }) => SogChunkInfo;
+  extractSogRegions: ({
+    id,
+    ranges,
+  }: {
+    id: number;
+    ranges: {
+      start: number;
+      count: number;
+    }[];
+  }) => import("../../../data/defines.js").ReorderedSplatResult[];
+  releaseSogChunk: ({
+    id,
+  }: {
+    id: number;
+  }) => void;
+  parseSogIndex: ({
+    bytes,
+    baseUrl,
+  }: {
+    bytes: ArrayBuffer;
+    baseUrl: string;
+  }) => {
+    bounds: Float64Array<ArrayBuffer>;
+    leafOffsets: Uint32Array<ArrayBuffer>;
+    lods: Float64Array<ArrayBuffer>;
+    retainedIndexBytes: number;
+    urls: string[];
+    counts: Float64Array;
+    environment?: string;
+  };
+  selectSogLod: (request: SogLodRequest) => Uint32Array<ArrayBufferLike>;
 };