gaussian-splat-lite 1.2.2 → 1.3.0

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

@@ -1,19 +1,24 @@
-import { CPUOrderingUpdate, SplatMaterialOptions } from '../backend.cjs';
-import { Uniforms } from '../uniforms.cjs';
 import type * as THREE from "three";
+import type { CPUOrderingUpdate, SplatMaterialOptions } from "../backend.cjs";
+import type { Uniforms } from "../uniforms.cjs";
 /** WebGL materials and ordering-texture uploads. */
 export declare class WebGLSplatBackend {
-    readonly renderer: THREE.WebGLRenderer;
-    private readonly uniforms;
-    readonly kind = "webgl";
-    readonly material: THREE.ShaderMaterial;
-    private readonly ordering;
-    constructor(renderer: THREE.WebGLRenderer, uniforms: Uniforms, options: SplatMaterialOptions);
-    selectMaterial(stochastic: boolean): THREE.ShaderMaterial;
-    getOrderingCapacity(count: number): number;
-    get cpuOrdering(): Uint32Array | null;
-    setCPUOrdering(update: CPUOrderingUpdate): void;
-    /** Unsorted draws read no ordering; the next sort allocates it again. */
-    releaseOrdering(): void;
-    dispose(): void;
+  readonly renderer: THREE.WebGLRenderer;
+  private readonly uniforms;
+  readonly kind = "webgl";
+  readonly sortedMaterial: THREE.ShaderMaterial;
+  readonly stochasticMaterial: THREE.ShaderMaterial;
+  private readonly ordering;
+  constructor(
+    renderer: THREE.WebGLRenderer,
+    uniforms: Uniforms,
+    options: SplatMaterialOptions,
+  );
+  selectMaterial(stochastic: boolean): THREE.ShaderMaterial;
+  getOrderingCapacity(count: number): number;
+  get cpuOrdering(): Uint32Array | null;
+  setCPUOrdering(update: CPUOrderingUpdate): void;
+  /** Unsorted draws read no ordering; the next sort allocates it again. */
+  releaseOrdering(): void;
+  dispose(): void;
 }

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

@@ -1,19 +1,24 @@
-import { CPUOrderingUpdate, SplatMaterialOptions } from '../backend';
-import { Uniforms } from '../uniforms';
 import type * as THREE from "three";
+import type { CPUOrderingUpdate, SplatMaterialOptions } from "../backend.js";
+import type { Uniforms } from "../uniforms.js";
 /** WebGL materials and ordering-texture uploads. */
 export declare class WebGLSplatBackend {
-    readonly renderer: THREE.WebGLRenderer;
-    private readonly uniforms;
-    readonly kind = "webgl";
-    readonly material: THREE.ShaderMaterial;
-    private readonly ordering;
-    constructor(renderer: THREE.WebGLRenderer, uniforms: Uniforms, options: SplatMaterialOptions);
-    selectMaterial(stochastic: boolean): THREE.ShaderMaterial;
-    getOrderingCapacity(count: number): number;
-    get cpuOrdering(): Uint32Array | null;
-    setCPUOrdering(update: CPUOrderingUpdate): void;
-    /** Unsorted draws read no ordering; the next sort allocates it again. */
-    releaseOrdering(): void;
-    dispose(): void;
+  readonly renderer: THREE.WebGLRenderer;
+  private readonly uniforms;
+  readonly kind = "webgl";
+  readonly sortedMaterial: THREE.ShaderMaterial;
+  readonly stochasticMaterial: THREE.ShaderMaterial;
+  private readonly ordering;
+  constructor(
+    renderer: THREE.WebGLRenderer,
+    uniforms: Uniforms,
+    options: SplatMaterialOptions,
+  );
+  selectMaterial(stochastic: boolean): THREE.ShaderMaterial;
+  getOrderingCapacity(count: number): number;
+  get cpuOrdering(): Uint32Array | null;
+  setCPUOrdering(update: CPUOrderingUpdate): void;
+  /** Unsorted draws read no ordering; the next sort allocates it again. */
+  releaseOrdering(): void;
+  dispose(): void;
 }

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

@@ -1,4 +1,9 @@
-import { SplatMaterialOptions } from '../backend.cjs';
-import { Uniforms } from '../uniforms.cjs';
-import * as THREE from "three";
-export declare function createWebGLSplatMaterial(uniforms: Uniforms, options: SplatMaterialOptions): THREE.ShaderMaterial;
+import type * as THREE from "three";
+import type { SplatMaterialOptions } from "../backend.cjs";
+import type { Uniforms } from "../uniforms.cjs";
+/** Sorted and stochastic variants keep separate programs. */
+export declare function createWebGLSplatMaterial(
+  uniforms: Uniforms,
+  options: SplatMaterialOptions,
+  stochastic: boolean,
+): THREE.ShaderMaterial;

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

@@ -1,4 +1,9 @@
-import { SplatMaterialOptions } from '../backend';
-import { Uniforms } from '../uniforms';
-import * as THREE from "three";
-export declare function createWebGLSplatMaterial(uniforms: Uniforms, options: SplatMaterialOptions): THREE.ShaderMaterial;
+import type * as THREE from "three";
+import type { SplatMaterialOptions } from "../backend.js";
+import type { Uniforms } from "../uniforms.js";
+/** Sorted and stochastic variants keep separate programs. */
+export declare function createWebGLSplatMaterial(
+  uniforms: Uniforms,
+  options: SplatMaterialOptions,
+  stochastic: boolean,
+): THREE.ShaderMaterial;

package/dist/types/rendering/webgl/textureUtils.d.cts

@@ -1,3 +1,10 @@
-import * as THREE from "three";
-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 uploadU32DataTextureRows(renderer: THREE.WebGLRenderer, texture: THREE.Texture, width: number, rows: number, data: Uint32Array): void;
+import type * as THREE from "three";
+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 uploadU32DataTextureRows(
+  renderer: THREE.WebGLRenderer,
+  texture: THREE.Texture,
+  width: number,
+  rows: number,
+  data: Uint32Array,
+): void;

package/dist/types/rendering/webgl/textureUtils.d.ts

@@ -1,3 +1,10 @@
-import * as THREE from "three";
-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 uploadU32DataTextureRows(renderer: THREE.WebGLRenderer, texture: THREE.Texture, width: number, rows: number, data: Uint32Array): void;
+import type * as THREE from "three";
+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 uploadU32DataTextureRows(
+  renderer: THREE.WebGLRenderer,
+  texture: THREE.Texture,
+  width: number,
+  rows: number,
+  data: Uint32Array,
+): void;

package/dist/types/rendering/webgl-fallback/AccumulatorGenerator.d.cts

@@ -1,16 +1,14 @@
-import { WebGPURenderer } from 'three/webgpu';
-import { AccumulatorRenderOptions } from '../webgl/AccumulatorGenerator.cjs';
-import * as THREE from "three";
-export declare function createWebGLFallbackAccumulatorTarget(width: number, height: number, depth: number, stochasticSeeds: boolean): THREE.WebGLArrayRenderTarget;
+import type { WebGPURenderer } from "three/webgpu";
+import type { AccumulatorRenderOptions } from "../webgl/AccumulatorGenerator.cjs";
 /**
  * Rasterizes Splat records, and for stochastic targets stable sampling seeds,
  * into integer arrays.
  */
 export declare class WebGLFallbackAccumulatorGenerator {
-    readonly uniforms: import('../uniforms.cjs').Uniforms;
-    private readonly material;
-    private readonly quad;
-    constructor(stochasticSeeds: boolean);
-    generate(options: AccumulatorRenderOptions<WebGPURenderer>): void;
-    dispose(): void;
+  readonly uniforms: import("../uniforms.cjs").Uniforms;
+  private readonly material;
+  private readonly quad;
+  constructor(stochasticSeeds: boolean);
+  generate(options: AccumulatorRenderOptions<WebGPURenderer>): void;
+  dispose(): void;
 }

package/dist/types/rendering/webgl-fallback/AccumulatorGenerator.d.ts

@@ -1,16 +1,14 @@
-import { WebGPURenderer } from 'three/webgpu';
-import { AccumulatorRenderOptions } from '../webgl/AccumulatorGenerator';
-import * as THREE from "three";
-export declare function createWebGLFallbackAccumulatorTarget(width: number, height: number, depth: number, stochasticSeeds: boolean): THREE.WebGLArrayRenderTarget;
+import type { WebGPURenderer } from "three/webgpu";
+import type { AccumulatorRenderOptions } from "../webgl/AccumulatorGenerator.js";
 /**
  * Rasterizes Splat records, and for stochastic targets stable sampling seeds,
  * into integer arrays.
  */
 export declare class WebGLFallbackAccumulatorGenerator {
-    readonly uniforms: import('../uniforms').Uniforms;
-    private readonly material;
-    private readonly quad;
-    constructor(stochasticSeeds: boolean);
-    generate(options: AccumulatorRenderOptions<WebGPURenderer>): void;
-    dispose(): void;
+  readonly uniforms: import("../uniforms.js").Uniforms;
+  private readonly material;
+  private readonly quad;
+  constructor(stochasticSeeds: boolean);
+  generate(options: AccumulatorRenderOptions<WebGPURenderer>): void;
+  dispose(): void;
 }

package/dist/types/rendering/webgl-fallback/SplatBackend.d.cts

@@ -1,17 +1,21 @@
-import { WebGPURenderer } from 'three/webgpu';
-import { CPUOrderingUpdate, SplatMaterialOptions } from '../backend.cjs';
-import { NodeSplatBackend } from '../tsl/SplatBackend.cjs';
-import { Uniforms } from '../uniforms.cjs';
+import type { WebGPURenderer } from "three/webgpu";
+import type { CPUOrderingUpdate, SplatMaterialOptions } from "../backend.cjs";
+import { NodeSplatBackend } from "../tsl/SplatBackend.cjs";
+import type { Uniforms } from "../uniforms.cjs";
 /** TSL drawing with CPU-sorted indices stored in an integer texture. */
 export declare class WebGLFallbackSplatBackend extends NodeSplatBackend {
-    readonly kind = "webgl-fallback";
-    private readonly ordering;
-    private readonly orderingNode;
-    constructor(renderer: WebGPURenderer, uniforms: Uniforms, options: SplatMaterialOptions);
-    getOrderingCapacity(count: number): number;
-    get cpuOrdering(): Uint32Array | null;
-    setCPUOrdering(update: CPUOrderingUpdate): void;
-    /** Unsorted draws read no ordering; the next sort allocates it again. */
-    releaseOrdering(): void;
-    dispose(): void;
+  readonly kind = "webgl-fallback";
+  private readonly ordering;
+  private readonly orderingNode;
+  constructor(
+    renderer: WebGPURenderer,
+    uniforms: Uniforms,
+    options: SplatMaterialOptions,
+  );
+  getOrderingCapacity(count: number): number;
+  get cpuOrdering(): Uint32Array | null;
+  setCPUOrdering(update: CPUOrderingUpdate): void;
+  /** Unsorted draws read no ordering; the next sort allocates it again. */
+  releaseOrdering(): void;
+  dispose(): void;
 }

package/dist/types/rendering/webgl-fallback/SplatBackend.d.ts

@@ -1,17 +1,21 @@
-import { WebGPURenderer } from 'three/webgpu';
-import { CPUOrderingUpdate, SplatMaterialOptions } from '../backend';
-import { NodeSplatBackend } from '../tsl/SplatBackend';
-import { Uniforms } from '../uniforms';
+import type { WebGPURenderer } from "three/webgpu";
+import type { CPUOrderingUpdate, SplatMaterialOptions } from "../backend.js";
+import { NodeSplatBackend } from "../tsl/SplatBackend.js";
+import type { Uniforms } from "../uniforms.js";
 /** TSL drawing with CPU-sorted indices stored in an integer texture. */
 export declare class WebGLFallbackSplatBackend extends NodeSplatBackend {
-    readonly kind = "webgl-fallback";
-    private readonly ordering;
-    private readonly orderingNode;
-    constructor(renderer: WebGPURenderer, uniforms: Uniforms, options: SplatMaterialOptions);
-    getOrderingCapacity(count: number): number;
-    get cpuOrdering(): Uint32Array | null;
-    setCPUOrdering(update: CPUOrderingUpdate): void;
-    /** Unsorted draws read no ordering; the next sort allocates it again. */
-    releaseOrdering(): void;
-    dispose(): void;
+  readonly kind = "webgl-fallback";
+  private readonly ordering;
+  private readonly orderingNode;
+  constructor(
+    renderer: WebGPURenderer,
+    uniforms: Uniforms,
+    options: SplatMaterialOptions,
+  );
+  getOrderingCapacity(count: number): number;
+  get cpuOrdering(): Uint32Array | null;
+  setCPUOrdering(update: CPUOrderingUpdate): void;
+  /** Unsorted draws read no ordering; the next sort allocates it again. */
+  releaseOrdering(): void;
+  dispose(): void;
 }

package/dist/types/rendering/webgpu/ProjectedSplats.d.cts

@@ -1,69 +1,79 @@
-import { IndirectStorageBufferAttribute, WebGPURenderer } from 'three/webgpu';
-import { SplatAccumulator } from '../SplatAccumulator.cjs';
-import { SplatGeometry } from '../SplatGeometry.cjs';
-import { ProjectedVertexData } from '../tsl/SplatMaterial.cjs';
-import { Uniforms } from '../uniforms.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type {
+  IndirectStorageBufferAttribute,
+  WebGPURenderer,
+} from "three/webgpu";
+import type { SplatAccumulator } from "../SplatAccumulator.cjs";
+import type { SplatGeometry } from "../SplatGeometry.cjs";
+import type { ProjectedVertexData } from "../tsl/SplatMaterial.cjs";
+import type { Uniforms } from "../uniforms.cjs";
 /** Fixed compute graph. Source mappings and storage may change without rebuilding shaders. */
 export declare class ProjectedSplats {
-    private readonly renderer;
-    private readonly uniforms;
-    readonly indirect: IndirectStorageBufferAttribute;
-    /** Common kernels, the full sorter and the first slot are ready; remaining slots warm automatically. */
-    readonly ready: Promise<void>;
-    error: unknown;
-    /**
-     * Called when kernels for a new WebXR eye count can draw, or when a slot
-     * fails to compile. Draws hide Splats until then, so on-demand hosts must
-     * redraw.
-     */
-    onKernelsReady?: () => void;
-    private readonly limits;
-    private readonly cache;
-    private readonly visibleCount;
-    private readonly keys;
-    private readonly seeds;
-    private readonly sorter;
-    private readonly slotSets;
-    private readonly compilations;
-    private readonly onSessionStart;
-    private shrinkViews;
-    private readonly onSessionEnd;
-    private readonly resetCount;
-    private readonly finish;
-    private readonly state;
-    private readonly matrix;
-    private readonly translation;
-    private readonly scale;
-    private readonly viewPosition;
-    private capacity;
-    private viewCapacity;
-    private disposed;
-    private projectedInputs;
-    constructor(renderer: WebGPURenderer, uniforms: Uniforms);
-    private createSlot;
-    /** Projection uniforms of each eye after the first, created on demand. */
-    private ensureEyeUniforms;
-    private createSlotSet;
-    /**
-     * Compiled slots that project this many eyes. One eye uses the startup
-     * slots; WebXR eye counts build theirs on first request.
-     */
-    private getSlots;
-    private compileSlots;
-    vertexData(camera: THREE.Camera, stochastic: boolean): ProjectedVertexData;
-    private resizeBuffer;
-    private resize;
-    render(accumulator: SplatAccumulator, camera: THREE.Camera, geometry: SplatGeometry, radial: boolean, fastSort: boolean, shrink?: boolean): boolean;
-    /** Projection uniforms for one eye; eye 0 also serves mono draws. */
-    private setEye;
-    /** Sort from the views' mean pose: the camera, or the WebXR head. */
-    private setSortPose;
-    /**
-     * Generates, projects, compacts and sorts the meshes any view draws. Sorted
-     * modes also visit hidden meshes, which only mark their keys absent.
-     */
-    private dispatch;
-    dispose(): void;
-    private disposeResources;
+  private readonly renderer;
+  private readonly uniforms;
+  readonly indirect: IndirectStorageBufferAttribute;
+  /** Common and sorting kernels plus the first mono and stereo slots are ready to draw. */
+  readonly ready: Promise<void>;
+  error: unknown;
+  /**
+   * Compact storage and refresh existing bindings without compiling or
+   * stopping draws. Reads the Splat count once startup slots have compiled.
+   */
+  shrinkResources(getCount: () => number): Promise<void>;
+  /** Requests a redraw when an XR session ends and eye storage can shrink. */
+  onViewsReleased?: () => void;
+  private readonly limits;
+  private readonly cache;
+  private readonly visibleCount;
+  private readonly keys;
+  private readonly seeds;
+  private readonly sorter;
+  private readonly slotSets;
+  private readonly nodes;
+  private kernelWork;
+  private shrinkViews;
+  private readonly onSessionEnd;
+  private readonly resetCount;
+  private readonly finish;
+  private readonly state;
+  private readonly matrix;
+  private readonly translation;
+  private readonly scale;
+  private readonly viewPosition;
+  private capacity;
+  private viewCapacity;
+  private disposed;
+  private projectedInputs;
+  private pendingInputs;
+  constructor(renderer: WebGPURenderer, uniforms: Uniforms);
+  private createSlot;
+  /** Projection uniforms of the precompiled eyes after the first. */
+  private ensureEyeUniforms;
+  private createSlotSet;
+  /** Warm the remaining slots at startup, yielding between each compilation. */
+  private compileSlots;
+  /** The selected, precompiled mode for mono or WebXR stereo. */
+  private getSlots;
+  private compact;
+  vertexData(camera: THREE.Camera, stochastic: boolean): ProjectedVertexData;
+  private resizeBuffer;
+  private resize;
+  render(
+    accumulator: SplatAccumulator,
+    camera: THREE.Camera,
+    geometry: SplatGeometry,
+    radial: boolean,
+    fastSort: boolean,
+  ): boolean;
+  /** Projection uniforms for one eye; eye 0 also serves mono draws. */
+  private setEye;
+  /** Sort from the views' mean pose: the camera, or the WebXR head. */
+  private setSortPose;
+  /**
+   * Generates, projects, compacts and sorts the meshes any view draws. Sorted
+   * modes also visit hidden meshes, which only mark their keys absent.
+   */
+  private dispatch;
+  dispose(): void;
+  private disposeResources;
 }

package/dist/types/rendering/webgpu/ProjectedSplats.d.ts

@@ -1,69 +1,79 @@
-import { IndirectStorageBufferAttribute, WebGPURenderer } from 'three/webgpu';
-import { SplatAccumulator } from '../SplatAccumulator';
-import { SplatGeometry } from '../SplatGeometry';
-import { ProjectedVertexData } from '../tsl/SplatMaterial';
-import { Uniforms } from '../uniforms';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type {
+  IndirectStorageBufferAttribute,
+  WebGPURenderer,
+} from "three/webgpu";
+import type { SplatAccumulator } from "../SplatAccumulator.js";
+import type { SplatGeometry } from "../SplatGeometry.js";
+import type { ProjectedVertexData } from "../tsl/SplatMaterial.js";
+import type { Uniforms } from "../uniforms.js";
 /** Fixed compute graph. Source mappings and storage may change without rebuilding shaders. */
 export declare class ProjectedSplats {
-    private readonly renderer;
-    private readonly uniforms;
-    readonly indirect: IndirectStorageBufferAttribute;
-    /** Common kernels, the full sorter and the first slot are ready; remaining slots warm automatically. */
-    readonly ready: Promise<void>;
-    error: unknown;
-    /**
-     * Called when kernels for a new WebXR eye count can draw, or when a slot
-     * fails to compile. Draws hide Splats until then, so on-demand hosts must
-     * redraw.
-     */
-    onKernelsReady?: () => void;
-    private readonly limits;
-    private readonly cache;
-    private readonly visibleCount;
-    private readonly keys;
-    private readonly seeds;
-    private readonly sorter;
-    private readonly slotSets;
-    private readonly compilations;
-    private readonly onSessionStart;
-    private shrinkViews;
-    private readonly onSessionEnd;
-    private readonly resetCount;
-    private readonly finish;
-    private readonly state;
-    private readonly matrix;
-    private readonly translation;
-    private readonly scale;
-    private readonly viewPosition;
-    private capacity;
-    private viewCapacity;
-    private disposed;
-    private projectedInputs;
-    constructor(renderer: WebGPURenderer, uniforms: Uniforms);
-    private createSlot;
-    /** Projection uniforms of each eye after the first, created on demand. */
-    private ensureEyeUniforms;
-    private createSlotSet;
-    /**
-     * Compiled slots that project this many eyes. One eye uses the startup
-     * slots; WebXR eye counts build theirs on first request.
-     */
-    private getSlots;
-    private compileSlots;
-    vertexData(camera: THREE.Camera, stochastic: boolean): ProjectedVertexData;
-    private resizeBuffer;
-    private resize;
-    render(accumulator: SplatAccumulator, camera: THREE.Camera, geometry: SplatGeometry, radial: boolean, fastSort: boolean, shrink?: boolean): boolean;
-    /** Projection uniforms for one eye; eye 0 also serves mono draws. */
-    private setEye;
-    /** Sort from the views' mean pose: the camera, or the WebXR head. */
-    private setSortPose;
-    /**
-     * Generates, projects, compacts and sorts the meshes any view draws. Sorted
-     * modes also visit hidden meshes, which only mark their keys absent.
-     */
-    private dispatch;
-    dispose(): void;
-    private disposeResources;
+  private readonly renderer;
+  private readonly uniforms;
+  readonly indirect: IndirectStorageBufferAttribute;
+  /** Common and sorting kernels plus the first mono and stereo slots are ready to draw. */
+  readonly ready: Promise<void>;
+  error: unknown;
+  /**
+   * Compact storage and refresh existing bindings without compiling or
+   * stopping draws. Reads the Splat count once startup slots have compiled.
+   */
+  shrinkResources(getCount: () => number): Promise<void>;
+  /** Requests a redraw when an XR session ends and eye storage can shrink. */
+  onViewsReleased?: () => void;
+  private readonly limits;
+  private readonly cache;
+  private readonly visibleCount;
+  private readonly keys;
+  private readonly seeds;
+  private readonly sorter;
+  private readonly slotSets;
+  private readonly nodes;
+  private kernelWork;
+  private shrinkViews;
+  private readonly onSessionEnd;
+  private readonly resetCount;
+  private readonly finish;
+  private readonly state;
+  private readonly matrix;
+  private readonly translation;
+  private readonly scale;
+  private readonly viewPosition;
+  private capacity;
+  private viewCapacity;
+  private disposed;
+  private projectedInputs;
+  private pendingInputs;
+  constructor(renderer: WebGPURenderer, uniforms: Uniforms);
+  private createSlot;
+  /** Projection uniforms of the precompiled eyes after the first. */
+  private ensureEyeUniforms;
+  private createSlotSet;
+  /** Warm the remaining slots at startup, yielding between each compilation. */
+  private compileSlots;
+  /** The selected, precompiled mode for mono or WebXR stereo. */
+  private getSlots;
+  private compact;
+  vertexData(camera: THREE.Camera, stochastic: boolean): ProjectedVertexData;
+  private resizeBuffer;
+  private resize;
+  render(
+    accumulator: SplatAccumulator,
+    camera: THREE.Camera,
+    geometry: SplatGeometry,
+    radial: boolean,
+    fastSort: boolean,
+  ): boolean;
+  /** Projection uniforms for one eye; eye 0 also serves mono draws. */
+  private setEye;
+  /** Sort from the views' mean pose: the camera, or the WebXR head. */
+  private setSortPose;
+  /**
+   * Generates, projects, compacts and sorts the meshes any view draws. Sorted
+   * modes also visit hidden meshes, which only mark their keys absent.
+   */
+  private dispatch;
+  dispose(): void;
+  private disposeResources;
 }