ice3 0.0.0-stage → 0.1.1

package/dist/_types/renderer/WebGL2GeometryCache.d.ts

@@ -0,0 +1,42 @@
+import type { ICEGeometry } from '../core/index.js';
+export interface GeometryEntry {
+    readonly vertexArray: WebGLVertexArrayObject;
+    readonly positionBuffer: WebGLBuffer;
+    readonly triangleIndexBuffer: WebGLBuffer;
+    readonly edgeIndexBuffer: WebGLBuffer | null;
+    readonly colorBuffer: WebGLBuffer | null;
+    readonly semanticBuffer: WebGLBuffer | null;
+    readonly triangleCount: number;
+    readonly edgeCount: number;
+    readonly bytes: number;
+    lastUsedFrame: number;
+}
+export interface WebGL2GeometryCacheOptions {
+    readonly inactiveGraceFrames?: number;
+    readonly maxBytes?: number;
+}
+export declare class WebGL2GeometryCache {
+    private readonly entries;
+    private active;
+    private readonly pinned;
+    private gl;
+    private uploads;
+    private evictions;
+    private frameId;
+    private readonly inactiveGraceFrames;
+    private readonly maxBytes;
+    constructor(options?: WebGL2GeometryCacheOptions);
+    retain(gl: WebGL2RenderingContext, geometry: ICEGeometry): Readonly<GeometryEntry>;
+    beginFrame(): void;
+    pin(gl: WebGL2RenderingContext, geometry: ICEGeometry): Readonly<GeometryEntry>;
+    unpin(geometry: ICEGeometry): void;
+    endFrame(): void;
+    clear(): void;
+    dispose(): void;
+    get totalBytes(): number;
+    get uploadCount(): number;
+    get evictionCount(): number;
+    private deleteEntry;
+    private enforceBudget;
+}
+//# sourceMappingURL=WebGL2GeometryCache.d.ts.map

package/dist/_types/renderer/WebGL2InstanceBatch.d.ts

@@ -0,0 +1,41 @@
+import type { ICEBasicMaterial, ICEGeometry } from '../core/index.js';
+import { WebGL2GeometryCache } from './WebGL2GeometryCache.js';
+import type { ICEGeometryRenderable } from './WebGL2GeometryBatch.js';
+export type { ICEGeometryRenderable } from './WebGL2GeometryBatch.js';
+export interface ICEInstanceBatch {
+    readonly id: string;
+    readonly geometry: ICEGeometry;
+    readonly material: ICEBasicMaterial;
+    readonly instanceMatrices: Float32Array;
+    readonly semanticIds: readonly string[];
+    readonly semanticIndices: Uint32Array;
+    readonly meshIds: readonly string[];
+    readonly materialKey: string;
+}
+export interface WebGL2InstanceEntry {
+    readonly vertexArray: WebGLVertexArrayObject;
+    readonly matrixBuffer: WebGLBuffer;
+    readonly semanticBuffer: WebGLBuffer;
+    readonly triangleIndexBuffer: WebGLBuffer;
+    readonly edgeIndexBuffer: WebGLBuffer | null;
+    readonly triangleCount: number;
+    readonly edgeCount: number;
+    instanceCount: number;
+    readonly bytes: number;
+}
+export declare class WebGL2InstanceCache {
+    private readonly entries;
+    private active;
+    private gl;
+    private fallbacks;
+    retain(gl: WebGL2RenderingContext, geometryCache: WebGL2GeometryCache, batch: ICEInstanceBatch): Readonly<WebGL2InstanceEntry> | undefined;
+    beginFrame(): void;
+    endFrame(): void;
+    clear(): void;
+    dispose(): void;
+    get fallbackCount(): number;
+    get totalBytes(): number;
+    private deleteEntry;
+}
+export declare function collectInstanceBatches(renderables: readonly ICEGeometryRenderable[], output?: ICEInstanceBatch[]): readonly ICEInstanceBatch[];
+//# sourceMappingURL=WebGL2InstanceBatch.d.ts.map

package/dist/_types/renderer/WebGL2PickCodec.d.ts

@@ -0,0 +1,3 @@
+export declare function encodeSelectionIndex(index: number): readonly [number, number, number, 255];
+export declare function decodeSelectionIndex(pixel: ArrayLike<number>): number | undefined;
+//# sourceMappingURL=WebGL2PickCodec.d.ts.map

package/dist/_types/renderer/WebGL2Picker.d.ts

@@ -0,0 +1,24 @@
+import type { ICEGeometryRenderable } from './WebGL2GeometryBatch.js';
+import type { WebGL2GeometryCache } from './WebGL2GeometryCache.js';
+import type { ICEInstanceBatch, WebGL2InstanceCache } from './WebGL2InstanceBatch.js';
+import type { ICERenderBatchDraw } from './WebGL2RenderBatch.js';
+import type { ICEFrame, ICEScreenPoint } from './types.js';
+export type ICEPickFrame = ICEFrame & {
+    readonly point: ICEScreenPoint;
+};
+export declare class WebGL2Picker {
+    private readonly gl;
+    private readonly program;
+    private readonly semanticProgram;
+    private framebuffer;
+    private colorTexture;
+    private depthBuffer;
+    private width;
+    private height;
+    constructor(gl: WebGL2RenderingContext);
+    pick(frame: ICEPickFrame, cache: WebGL2GeometryCache, renderables: readonly ICEGeometryRenderable[], batches?: readonly ICERenderBatchDraw[], instances?: readonly ICEInstanceBatch[], instanceCache?: WebGL2InstanceCache | null): string | undefined;
+    dispose(): void;
+    private ensureTarget;
+    private releaseTarget;
+}
+//# sourceMappingURL=WebGL2Picker.d.ts.map

package/dist/_types/renderer/WebGL2Program.d.ts

@@ -0,0 +1,25 @@
+import type { ICEMatrix4 } from '../core/index.js';
+export declare class WebGL2Program {
+    private readonly gl;
+    static readonly POSITION_ATTRIBUTE = 0;
+    static readonly COLOR_ATTRIBUTE = 1;
+    static readonly INSTANCE_MATRIX_ATTRIBUTE = 3;
+    static readonly INSTANCE_SEMANTIC_ATTRIBUTE = 7;
+    readonly program: WebGLProgram;
+    private readonly matrixLocation;
+    private readonly colorLocation;
+    private readonly clipOffsetLocation;
+    private readonly vertexColorLocation;
+    private readonly instancingLocation;
+    constructor(gl: WebGL2RenderingContext);
+    use(): void;
+    setMatrix(matrix: ICEMatrix4): void;
+    setColor(color: readonly [number, number, number, number]): void;
+    setClipOffset(x: number, y: number): void;
+    setVertexColors(enabled: boolean): void;
+    setInstancing(enabled: boolean): void;
+    dispose(): void;
+    private createProgram;
+    private compile;
+}
+//# sourceMappingURL=WebGL2Program.d.ts.map

package/dist/_types/renderer/WebGL2RenderBatch.d.ts

@@ -0,0 +1,17 @@
+import type { ICEBasicMaterial, ICEGeometry, ICENode, ICEScene } from '../core/index.js';
+export interface ICERenderBatchNode extends ICENode {
+    readonly geometry: ICEGeometry;
+    readonly material: ICEBasicMaterial;
+    readonly semanticIds: readonly string[];
+    readonly semanticNodeIds: readonly string[];
+    readonly semanticSelectionIds: readonly string[];
+    readonly materialKey: string;
+}
+export interface ICERenderBatchDraw {
+    readonly id: string;
+    readonly batch: ICERenderBatchNode;
+    readonly worldMatrix: Float32Array;
+}
+export declare function collectRenderBatches(scene: ICEScene, output?: ICERenderBatchDraw[]): readonly ICERenderBatchDraw[];
+export declare function semanticSelectionId(batch: Pick<ICERenderBatchNode, 'semanticSelectionIds'>, semanticIndex: number): string | undefined;
+//# sourceMappingURL=WebGL2RenderBatch.d.ts.map

package/dist/_types/renderer/WebGL2RendererBackend.d.ts

@@ -0,0 +1,44 @@
+import { type ICEGeometry } from '../core/index.js';
+import type { ICERendererBackend, ICERendererCapabilities, ICEFrame, ICEScreenPoint, ICEViewport } from './types.js';
+export declare function colorToRgba(color: string): readonly [number, number, number, number];
+export declare class WebGL2RendererBackend implements ICERendererBackend {
+    capabilities: Readonly<ICERendererCapabilities>;
+    private canvas;
+    private gl;
+    private viewport;
+    private dpr;
+    private onContextLost;
+    private onContextRestored;
+    private program;
+    private semanticProgram;
+    private geometryCache;
+    private instanceCache;
+    private picker;
+    private readonly mvpScratch;
+    private readonly worldScratch;
+    private readonly renderablesScratch;
+    private readonly batchesScratch;
+    private readonly instancesScratch;
+    private readonly instancedMeshIds;
+    private backgroundRgba;
+    private frameStats;
+    private readonly handleContextLost;
+    private readonly handleContextRestored;
+    initialize(options: {
+        readonly canvas: HTMLCanvasElement;
+        readonly onContextLost?: () => void;
+        readonly onContextRestored?: () => void;
+    }): void;
+    resize(viewport: ICEViewport, dpr: number): void;
+    setBackgroundColor(color: string): void;
+    prepareBatchGeometry(geometry: ICEGeometry): void;
+    releaseBatchGeometry(geometry: ICEGeometry): void;
+    render(frame: ICEFrame): void;
+    pick(frame: ICEFrame, point: ICEScreenPoint): string | undefined;
+    dispose(): void;
+    getViewport(): ICEViewport;
+    getDevicePixelRatio(): number;
+    get stats(): Readonly<typeof this.frameStats>;
+    private createProgram;
+}
+//# sourceMappingURL=WebGL2RendererBackend.d.ts.map

package/dist/_types/renderer/WebGL2SemanticProgram.d.ts

@@ -0,0 +1,21 @@
+import type { ICEMatrix4 } from '../core/index.js';
+export declare class WebGL2SemanticProgram {
+    private readonly gl;
+    private readonly program;
+    private readonly matrixLocation;
+    private readonly pickModeLocation;
+    private readonly pickBaseLocation;
+    private readonly highlightLocation;
+    private readonly colorLocation;
+    private readonly instancingLocation;
+    constructor(gl: WebGL2RenderingContext);
+    use(): void;
+    setMatrix(matrix: ICEMatrix4): void;
+    setPick(base: number): void;
+    setHighlight(semanticIndex: number): void;
+    setInstancing(enabled: boolean): void;
+    dispose(): void;
+    private createProgram;
+    private compile;
+}
+//# sourceMappingURL=WebGL2SemanticProgram.d.ts.map

package/dist/_types/renderer/index.d.ts

@@ -0,0 +1,12 @@
+export { FakeRendererBackend } from './FakeRendererBackend.js';
+export { WebGL2RendererBackend, colorToRgba, } from './WebGL2RendererBackend.js';
+export { collectRenderables } from './WebGL2GeometryBatch.js';
+export type { ICEGeometryRenderable } from './WebGL2GeometryBatch.js';
+export { collectInstanceBatches } from './WebGL2InstanceBatch.js';
+export type { ICEInstanceBatch } from './WebGL2InstanceBatch.js';
+export { queueBatchGeneration } from './ICEWebGL2BatchGenerationUploader.js';
+export type { ICEBatchGenerationHandle, ICEBatchUploadBuffer, ICEBatchUploadOptions, } from './ICEWebGL2BatchGenerationUploader.js';
+export { collectRenderBatches } from './WebGL2RenderBatch.js';
+export type { ICERenderBatchDraw, ICERenderBatchNode, } from './WebGL2RenderBatch.js';
+export type { ICERendererBackend, ICERendererCapabilities, ICERendererStats, ICEFrame, ICEScreenPoint, ICEViewport, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/renderer/types.d.ts

@@ -0,0 +1,51 @@
+import type { ICEGeometry, ICEPerspectiveCamera, ICEScene } from '../core/index.js';
+export type ICEViewport = {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+};
+export type ICEScreenPoint = Readonly<{
+    x: number;
+    y: number;
+}>;
+export type ICEFrame = {
+    readonly frameId: number;
+    readonly scene: ICEScene;
+    readonly camera: ICEPerspectiveCamera;
+    readonly viewport: ICEViewport;
+    readonly dpr: number;
+    readonly selection: readonly string[];
+};
+export interface ICERendererCapabilities {
+    readonly backend: 'webgl2' | 'fake';
+    readonly maxTextureSize: number;
+    readonly picking: boolean;
+}
+export interface ICERendererStats {
+    readonly drawCalls: number;
+    readonly renderedMeshes: number;
+    readonly renderedBatches: number;
+    readonly instancingFallbacks: number;
+    readonly gpuUploads: number;
+    readonly gpuEvictions: number;
+    readonly gpuBytes: number;
+}
+export interface ICERendererBackend {
+    readonly capabilities: Readonly<ICERendererCapabilities>;
+    readonly stats?: Readonly<ICERendererStats>;
+    initialize(options: {
+        readonly canvas: HTMLCanvasElement;
+        readonly onContextLost?: () => void;
+        readonly onContextRestored?: () => void;
+    }): void;
+    resize(viewport: ICEViewport, dpr: number): void;
+    setBackgroundColor?(color: string): void;
+    prepareBatchGeometry?(geometry: ICEGeometry): void;
+    releaseBatchGeometry?(geometry: ICEGeometry): void;
+    pick?(frame: ICEFrame, point: ICEScreenPoint): string | undefined;
+    render(frame: ICEFrame): void;
+    capture?(): Promise<Blob>;
+    dispose(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/_types/runtime/ICE3.d.ts

@@ -0,0 +1,121 @@
+import { ICEEventDispatcher, ICEPerspectiveCamera, ICEScene, type ICEDiagnostic, type ICEGeometry, type ICENode } from '../core/index.js';
+import { type ICERendererBackend, type ICEScreenPoint, type ICEViewport } from '../renderer/index.js';
+import { ICE2DLayer } from './layer/ICE2DLayer.js';
+import { type ICEProjectedPoint } from './ICEProjection.js';
+import { type ICERenderScheduler } from './ICERenderScheduler.js';
+import type { ICEVector3Tuple } from '../core/index.js';
+import { type ICERay, type ICESceneItem, type ICESceneQuery } from './query/ICESceneQuery.js';
+export type ICE3Options = {
+    readonly backend?: ICERendererBackend;
+    readonly scheduler?: ICERenderScheduler;
+};
+export type ICEEngineDiagnostics = {
+    readonly frameId: number;
+    readonly fps: number;
+    readonly cpuFrameTimeMs: number;
+    readonly backend: Readonly<{
+        backend: 'webgl2' | 'fake';
+        maxTextureSize: number;
+        picking: boolean;
+    }>;
+    readonly nodeCount: number;
+    readonly layerCount: number;
+    readonly labelCount: number;
+    readonly dpr: number;
+    readonly canvas: Readonly<{
+        width: number;
+        height: number;
+    }>;
+    readonly viewport: Readonly<ICEViewport>;
+    readonly contextLossCount: number;
+    readonly renderer: Readonly<{
+        drawCalls: number;
+        renderedMeshes: number;
+        renderedBatches: number;
+        instancingFallbacks: number;
+        gpuUploads: number;
+        gpuEvictions: number;
+        gpuBytes: number;
+    }>;
+    readonly selectionCount: number;
+    readonly lastPickTimeMs: number;
+    readonly lastPickId?: string;
+    readonly labels: readonly Readonly<{
+        id: string;
+        layerId: string;
+        rect: Readonly<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }>;
+    }>[];
+    readonly lastDiagnostic?: Readonly<ICEDiagnostic>;
+};
+export declare class ICE3 extends ICEEventDispatcher {
+    private readonly backend;
+    private readonly scheduler;
+    private readonly interaction;
+    private readonly layers;
+    private readonly layerRouter;
+    private readonly layerPainter;
+    private readonly inputRouter;
+    private state;
+    private host;
+    private baseCanvas;
+    private overlayCanvas;
+    private generatedBaseCanvas;
+    private generatedOverlayCanvas;
+    private scene;
+    private camera;
+    private viewport;
+    private dpr;
+    private frameId;
+    private renderPending;
+    private lastFrameAt;
+    private fps;
+    private cpuFrameTimeMs;
+    private contextLost;
+    private contextLossCount;
+    private lastPickTimeMs;
+    private lastPickId;
+    private readonly pointerGestures;
+    private lastDiagnostic;
+    private instancingFallbackReported;
+    private readonly removeInputListeners;
+    private readonly handleWindowResize;
+    constructor(options?: ICE3Options);
+    init(target: string | HTMLElement): this;
+    setScene(scene: ICEScene): this;
+    setCamera(camera: ICEPerspectiveCamera): this;
+    setBackgroundColor(color: string): this;
+    prepareRenderBatchGeometry(geometry: ICEGeometry): this;
+    releaseRenderBatchGeometry(geometry: ICEGeometry): this;
+    addLayer(layer: ICE2DLayer): this;
+    removeLayer(layer: ICE2DLayer): this;
+    start(): this;
+    stop(): this;
+    requestRender(_reason?: string): this;
+    project(position: ICEVector3Tuple): ICEProjectedPoint;
+    getSelection(): readonly string[];
+    queryScene(query?: ICESceneQuery): readonly ICESceneItem[];
+    findBySelectionId(selectionId: string): ICENode | undefined;
+    raycast(ray: ICERay): ICESceneItem | undefined;
+    setSelection(ids: readonly string[]): this;
+    pick(point: ICEScreenPoint): ICENode | undefined;
+    pickItem(point: ICEScreenPoint): {
+        readonly item?: ICESceneItem;
+    };
+    getDiagnostics(): Readonly<ICEEngineDiagnostics>;
+    destroy(): void;
+    resize(): this;
+    private configureTarget;
+    private renderFrame;
+    private installInputEvents;
+    private dispatchInput;
+    private samplePick;
+    private assertActive;
+    reportDiagnostic(code: string, message: string, severity?: ICEDiagnostic['severity']): this;
+    private recordDiagnostic;
+}
+//# sourceMappingURL=ICE3.d.ts.map

package/dist/_types/runtime/ICEInteractionState.d.ts

@@ -0,0 +1,7 @@
+import { ICEEventDispatcher } from '../core/index.js';
+export declare class ICEInteractionState extends ICEEventDispatcher {
+    private selection;
+    getSelection(): readonly string[];
+    setSelection(ids: readonly string[]): this;
+}
+//# sourceMappingURL=ICEInteractionState.d.ts.map

package/dist/_types/runtime/ICEProjection.d.ts

@@ -0,0 +1,10 @@
+import { ICEPerspectiveCamera, type ICEVector3Tuple } from '../core/index.js';
+import type { ICEViewport } from '../renderer/index.js';
+export interface ICEProjectedPoint {
+    readonly x: number;
+    readonly y: number;
+    readonly visible: boolean;
+    readonly depth: number;
+}
+export declare function projectWorldPoint(camera: ICEPerspectiveCamera, position: ICEVector3Tuple, viewport: ICEViewport): ICEProjectedPoint;
+//# sourceMappingURL=ICEProjection.d.ts.map

package/dist/_types/runtime/ICERenderScheduler.d.ts

@@ -0,0 +1,14 @@
+export interface ICERenderScheduler {
+    request(callback: FrameRequestCallback): number;
+    cancelAll(): void;
+    flushForTest(): boolean;
+    pendingCount(): number;
+}
+export declare class BrowserRenderScheduler implements ICERenderScheduler {
+    private readonly pending;
+    request(callback: FrameRequestCallback): number;
+    cancelAll(): void;
+    flushForTest(): boolean;
+    pendingCount(): number;
+}
+//# sourceMappingURL=ICERenderScheduler.d.ts.map

package/dist/_types/runtime/asset/ICEAssetLoader.d.ts

@@ -0,0 +1,30 @@
+import type { ICEPreparedContract, ICEPreparedStats } from '../../assets/index.js';
+import type { ICEGeometryBounds, ICEScene } from '../../core/index.js';
+import type { ICE3 } from '../ICE3.js';
+export interface ICEAssetLoaderOptions {
+    readonly fetch?: typeof globalThis.fetch;
+    readonly verifyIntegrity?: boolean;
+}
+export interface ICEAssetLoadOptions {
+    readonly signal?: AbortSignal;
+}
+export interface ICEAssetHandle {
+    readonly id: string;
+    readonly scene: ICEScene;
+    readonly bounds: ICEGeometryBounds;
+    readonly stats: ICEPreparedStats;
+    readonly contract: ICEPreparedContract;
+    dispose(): void;
+}
+export declare class ICEAssetLoader {
+    private readonly engine;
+    private readonly fetcher;
+    private readonly verifyIntegrity;
+    private readonly legacyWarnings;
+    private readonly cache;
+    constructor(engine: ICE3, options?: ICEAssetLoaderOptions);
+    load(url: string, options?: ICEAssetLoadOptions): Promise<ICEAssetHandle>;
+    clear(url?: string): void;
+    private fetchSnapshot;
+}
+//# sourceMappingURL=ICEAssetLoader.d.ts.map

package/dist/_types/runtime/asset/ICEAssetSceneBuilder.d.ts

@@ -0,0 +1,9 @@
+import type { ICEPreparedAssetSnapshot, ICEPreparedStats } from '../../assets/index.js';
+import { ICEScene, type ICEGeometryBounds } from '../../core/index.js';
+export interface ICEBuiltAsset {
+    readonly scene: ICEScene;
+    readonly bounds: ICEGeometryBounds;
+    readonly stats: ICEPreparedStats;
+}
+export declare function buildAssetScene(snapshot: ICEPreparedAssetSnapshot): ICEBuiltAsset;
+//# sourceMappingURL=ICEAssetSceneBuilder.d.ts.map

package/dist/_types/runtime/asset/ICELodSelector.d.ts

@@ -0,0 +1,21 @@
+import type { ICETilesetTile } from '../../assets/index.js';
+import { type ICEPerspectiveCamera } from '../../core/index.js';
+import type { ICEViewport } from '../../renderer/index.js';
+export interface ICELodSelectionInput {
+    readonly root: ICETilesetTile;
+    readonly camera: ICEPerspectiveCamera;
+    readonly viewport: ICEViewport;
+    readonly residentIds: ReadonlySet<string>;
+    readonly failedIds: ReadonlySet<string>;
+    readonly previousTargetIds?: ReadonlySet<string>;
+    readonly maxScreenSpaceErrorPixels: number;
+}
+export interface ICELodSelection {
+    readonly target: readonly ICETilesetTile[];
+    readonly prefetch: readonly ICETilesetTile[];
+    readonly fallbackByTargetId: ReadonlyMap<string, string>;
+}
+export declare class ICELodSelector {
+    select(input: ICELodSelectionInput): ICELodSelection;
+}
+//# sourceMappingURL=ICELodSelector.d.ts.map

package/dist/_types/runtime/asset/ICERenderBatch.d.ts

@@ -0,0 +1,21 @@
+import { ICENode, type ICEBasicMaterial, type ICEIndexedGeometry, type ICENodeOptions } from '../../core/index.js';
+export interface ICERenderBatchOptions extends ICENodeOptions {
+    readonly geometry: ICEIndexedGeometry;
+    readonly material: ICEBasicMaterial;
+    readonly semanticIds: readonly string[];
+    readonly semanticNodeIds: readonly string[];
+    readonly semanticSelectionIds: readonly string[];
+    readonly materialKey: string;
+}
+export declare class ICERenderBatch extends ICENode {
+    static readonly typeId = "ice3:RenderBatch";
+    readonly geometry: ICEIndexedGeometry;
+    readonly material: ICEBasicMaterial;
+    readonly semanticIds: readonly string[];
+    readonly semanticNodeIds: readonly string[];
+    readonly semanticSelectionIds: readonly string[];
+    readonly materialKey: string;
+    constructor(options: ICERenderBatchOptions);
+    get typeId(): string;
+}
+//# sourceMappingURL=ICERenderBatch.d.ts.map