ice3 0.1.1 → 0.2.0

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

@@ -0,0 +1,16 @@
+export declare class WebGPUTimestampProfiler {
+    private readonly device;
+    private readonly slots;
+    private readonly pending;
+    private reason;
+    private disposed;
+    constructor(device: GPUDevice, slotCount?: number);
+    get unavailableReason(): string | undefined;
+    querySetFor(frameId: number): GPUQuerySet;
+    resolveFrame(encoder: GPUCommandEncoder, frameId: number): void;
+    drain(): Promise<readonly number[]>;
+    dispose(): void;
+    private slotFor;
+    private slotIndex;
+}
+//# sourceMappingURL=WebGPUTimestampProfiler.d.ts.map

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

@@ -0,0 +1,27 @@
+import type { ICEGeometryBounds } from '../core/index.js';
+import type { ICEInstanceStoragePage } from './WebGPUInstanceStorage.js';
+export declare function createIndirectArguments(indexCount: number, firstIndex: number, baseVertex: number): Uint32Array | undefined;
+export declare function isAabbVisible(matrix: ArrayLike<number>, bounds: ICEGeometryBounds, viewProjection: ArrayLike<number>): boolean;
+export type ICEVisibilityEntry = Readonly<{
+    readonly visibleBuffer: GPUBuffer;
+    readonly indirectBuffer: GPUBuffer;
+    readonly instanceCount: number;
+}>;
+export declare class WebGPUVisibilityEncoder {
+    private readonly device;
+    readonly bindGroupLayout: GPUBindGroupLayout;
+    readonly pipeline: GPUComputePipeline;
+    private readonly entries;
+    private constructor();
+    static create(device: GPUDevice): Promise<WebGPUVisibilityEncoder>;
+    retain(page: ICEInstanceStoragePage, indexCount: number): ICEVisibilityEntry;
+    encode(encoder: GPUCommandEncoder, entry: ICEVisibilityEntry, page: ICEInstanceStoragePage, uniformBuffer: GPUBuffer, uniformOffset: number): void;
+    readStats(entry: ICEVisibilityEntry, page: ICEInstanceStoragePage): Promise<Readonly<{
+        visibleInstances: number;
+        culledInstances: number;
+        dispatchCount: number;
+    }>>;
+    dispose(): void;
+    private destroy;
+}
+//# sourceMappingURL=WebGPUVisibility.d.ts.map

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

@@ -1,12 +1,26 @@
 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 { selectDefaultRendererBackend, selectRendererBackend, type ICERendererBackendSelection, type ICERendererFactories, } from './RendererSelection.js';
+export { WebGPURendererBackend, type WebGPUDeviceContext, } from './WebGPURendererBackend.js';
+export { probeWebGPU } from './WebGPUProbe.js';
+export type { ICEWebGPUProbeFailureReason, ICEWebGPUProbeOptions, ICEWebGPUProbeResult, } from './WebGPUProbe.js';
+export { WebGPUGeometryCache, type WebGPUGeometryCacheOptions, type WebGPUGeometryEntry, } from './WebGPUGeometryCache.js';
+export { WebGPUInstanceCache, type WebGPUInstanceEntry, } from './WebGPUInstanceCache.js';
+export { WebGPUDrawStorage, type ICEWebGPUDrawUniform, } from './WebGPUDrawStorage.js';
+export { WebGPURenderPlanCache, type WebGPURenderPlan, } from './WebGPURenderPlan.js';
+export { detectWebGPUAcceleration, WEBGPU_GPU_DRIVEN_DEFAULT, WEBGPU_INSTANCE_VISIBILITY_THRESHOLD, WEBGPU_STORAGE_DEFAULT, type ICEWebGPUAcceleration, type ICEWebGPUAccelerationTier, type ICEWebGPUOptimizationStats, } from './WebGPUCapabilities.js';
+export { INSTANCE_RECORD_BYTES, WebGPUInstanceStorage, type ICEInstanceStorageEntry, type ICEInstanceStoragePage, type ICEInstanceStoragePagePlan, type WebGPUInstanceStorageOptions, } from './WebGPUInstanceStorage.js';
+export { createIndirectArguments, isAabbVisible, WebGPUVisibilityEncoder, type ICEVisibilityEntry, } from './WebGPUVisibility.js';
+export { WebGPUBundleCache } from './WebGPUBundleCache.js';
+export { buildSelectionMask, WebGPUSelectionMaskBuffer, type ICESelectionMaskLayout, } from './WebGPUSelectionMask.js';
+export { collectWebGPUPickIds, WebGPUPicker, } from './WebGPUPicker.js';
+export { collectRenderables, selectionIdentity, type ICEGeometryRenderable, } from './Renderables.js';
+export { collectInstanceBatches, type ICEInstanceBatch, } from './InstanceBatch.js';
 export { queueBatchGeneration } from './ICEWebGL2BatchGenerationUploader.js';
+export type { ICEFrameStageProfile, } from './RendererProfiler.js';
+export { RendererProfiler, } from './RendererProfiler.js';
+export { WebGPUTimestampProfiler } from './WebGPUTimestampProfiler.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';
+export { collectRenderBatches, semanticSelectionId, type ICERenderBatchDraw, type ICERenderBatchNode, } from './RenderBatch.js';
+export type { ICERendererBackend, ICERendererCapabilities, ICERendererStats, ICEFrame, ICEScreenPoint, ICEViewport, ICE3RendererPreference, ICE3RendererSelection, ICEWebGPUOptimizationFailureReason, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,10 +1,20 @@
-import type { ICEGeometry, ICEPerspectiveCamera, ICEScene } from '../core/index.js';
+import type { ICEGeometry, ICEEngineError, ICEPerspectiveCamera, ICEScene } from '../core/index.js';
 export type ICEViewport = {
     readonly x: number;
     readonly y: number;
     readonly width: number;
     readonly height: number;
 };
+export type ICEWebGPUOptimizationFailureReason = 'limit-too-low' | 'pipeline-failed' | 'resource-failed' | 'runtime-failed' | 'threshold-not-met';
+export type ICE3RendererPreference = 'auto' | 'webgpu' | 'webgl2';
+export type ICE3RendererSelection = Readonly<{
+    requested: ICE3RendererPreference | 'custom';
+    selected: 'webgl2' | 'webgpu' | 'fake';
+    fallback: boolean;
+    experimental: boolean;
+    probeDurationMs?: number;
+    fallbackReason?: import('./WebGPUProbe.js').ICEWebGPUProbeFailureReason;
+}>;
 export type ICEScreenPoint = Readonly<{
     x: number;
     y: number;
@@ -18,7 +28,7 @@ export type ICEFrame = {
     readonly selection: readonly string[];
 };
 export interface ICERendererCapabilities {
-    readonly backend: 'webgl2' | 'fake';
+    readonly backend: 'webgl2' | 'webgpu' | 'fake';
     readonly maxTextureSize: number;
     readonly picking: boolean;
 }
@@ -38,13 +48,15 @@ export interface ICERendererBackend {
         readonly canvas: HTMLCanvasElement;
         readonly onContextLost?: () => void;
         readonly onContextRestored?: () => void;
+        readonly onError?: (error: ICEEngineError) => 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;
+    pick?(frame: ICEFrame, point: ICEScreenPoint): Promise<string | undefined>;
     render(frame: ICEFrame): void;
+    finish?(): Promise<void>;
     capture?(): Promise<Blob>;
     dispose(): void;
 }

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

@@ -1,5 +1,5 @@
 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 { type ICE3RendererPreference, type ICE3RendererSelection, 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';
@@ -7,6 +7,7 @@ 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 renderer?: ICE3RendererPreference;
     readonly scheduler?: ICERenderScheduler;
 };
 export type ICEEngineDiagnostics = {
@@ -14,10 +15,11 @@ export type ICEEngineDiagnostics = {
     readonly fps: number;
     readonly cpuFrameTimeMs: number;
     readonly backend: Readonly<{
-        backend: 'webgl2' | 'fake';
+        backend: 'webgl2' | 'webgpu' | 'fake';
         maxTextureSize: number;
         picking: boolean;
     }>;
+    readonly rendererSelection: Readonly<ICE3RendererSelection>;
     readonly nodeCount: number;
     readonly layerCount: number;
     readonly labelCount: number;
@@ -53,7 +55,9 @@ export type ICEEngineDiagnostics = {
     readonly lastDiagnostic?: Readonly<ICEDiagnostic>;
 };
 export declare class ICE3 extends ICEEventDispatcher {
-    private readonly backend;
+    private backend;
+    private readonly rendererPreference;
+    private rendererSelection;
     private readonly scheduler;
     private readonly interaction;
     private readonly layers;
@@ -82,10 +86,13 @@ export declare class ICE3 extends ICEEventDispatcher {
     private readonly pointerGestures;
     private lastDiagnostic;
     private instancingFallbackReported;
+    private pickGeneration;
     private readonly removeInputListeners;
     private readonly handleWindowResize;
     constructor(options?: ICE3Options);
     init(target: string | HTMLElement): this;
+    initAsync(target: string | HTMLElement): Promise<this>;
+    private initializeWithBackend;
     setScene(scene: ICEScene): this;
     setCamera(camera: ICEPerspectiveCamera): this;
     setBackgroundColor(color: string): this;
@@ -102,10 +109,11 @@ export declare class ICE3 extends ICEEventDispatcher {
     findBySelectionId(selectionId: string): ICENode | undefined;
     raycast(ray: ICERay): ICESceneItem | undefined;
     setSelection(ids: readonly string[]): this;
-    pick(point: ICEScreenPoint): ICENode | undefined;
-    pickItem(point: ICEScreenPoint): {
+    pick(point: ICEScreenPoint): Promise<ICENode | undefined>;
+    pickItem(point: ICEScreenPoint): Promise<{
         readonly item?: ICESceneItem;
-    };
+    }>;
+    capture(): Promise<Blob>;
     getDiagnostics(): Readonly<ICEEngineDiagnostics>;
     destroy(): void;
     resize(): this;

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { ICEBasicMaterial, ICEBoxGeometry, ICEIndexedGeometry, ICEEngineError, ICEAssetLoader, ICETilesetHandle, ICETilesetLoader, ICELabel, ICEMesh, ICENode, ICEOrbitController, ICEPerspectiveCamera, ICEScene, ICEScreenLayer, ICETypeRegistry, ICEWorldLayer, ICE3, deserializeScene, serializeScene, } from './_types/runtime/index.js';
-export type { ICEDeserializedScene, ICEDiagnostic, ICEDiagnosticSeverity, ICEEngineDiagnostics, ICEInputEvent, ICEInputTarget, ICEKeyboardInputEvent, ICEProjectedPoint, ICEAssetHandle, ICEAssetLoaderOptions, ICEAssetLoadOptions, ICETilesetEvent, ICETilesetLoaderOptions, ICETilesetOpenOptions, ICETilesetStats, ICETilesetTileState, ICEPreparedContract, ICEPreparedStats, ICERenderBatchingOptions, ICESerializedScene, ICEGeometry, ICEGeometryBounds, ICEIndexedGeometryOptions, ICEMatrix4Tuple, ICEPickOutcome, } from './_types/runtime/index.js';
+export type { ICEDeserializedScene, ICEDiagnostic, ICEDiagnosticSeverity, ICEEngineDiagnostics, ICE3Options, ICE3RendererPreference, ICE3RendererSelection, ICEInputEvent, ICEInputTarget, ICEKeyboardInputEvent, ICEProjectedPoint, ICEAssetHandle, ICEAssetLoaderOptions, ICEAssetLoadOptions, ICETilesetEvent, ICETilesetLoaderOptions, ICETilesetOpenOptions, ICETilesetStats, ICETilesetTileState, ICEPreparedContract, ICEPreparedStats, ICERenderBatchingOptions, ICESerializedScene, ICEGeometry, ICEGeometryBounds, ICEIndexedGeometryOptions, ICEMatrix4Tuple, ICEPickOutcome, } from './_types/runtime/index.js';
 //# sourceMappingURL=index.d.ts.map