ice3 0.1.0 → 0.2.0

package/README.md

@@ -47,7 +47,16 @@ scene.addChild(new ICEMesh({
 engine.setScene(scene).setCamera(camera).start();
 ```
 
+默认使用 WebGL2。WebGPU 是实验性能力，必须显式使用
+`await new ICE3({ renderer: 'webgpu' }).initAsync(host)` 才会启用；`auto` 保留为
+WebGL2 兼容别名。拾取使用 `await engine.pick(point)`。
+
 完整文档和相关工具见
 [Engine 文档](https://github.com/ice-3d/ice3-engine/blob/main/README.md)。
 
+工业模型接入 Runtime 前，使用配套的
+[ICE3 Toolchain](https://github.com/ice-3d/ice3-toolchain/blob/main/README.md)
+进行离线格式转换、验证、切分、LOD 和 Tileset 发布。功能与格式支持见
+[Toolchain 功能指南](https://github.com/ice-3d/ice3-toolchain/blob/main/docs/guides/capabilities.md)。
+
 本项目采用 MIT License。

package/dist/_types/core/scene/ICENode.d.ts

@@ -50,13 +50,17 @@ export declare class ICENode extends ICEEventDispatcher {
     readonly position: ICEVector3;
     readonly rotation: ICEVector3;
     readonly scale: ICEVector3;
-    visible: boolean;
     private _parent;
     private readonly _children;
     private readonly worldMatrix;
     private localMatrixOverride;
+    private _visible;
+    private _revision;
     constructor(options: ICENodeOptions);
     get typeId(): string;
+    get visible(): boolean;
+    set visible(value: boolean);
+    get revision(): number;
     get parent(): ICENode | null;
     get children(): readonly ICENode[];
     addChild(node: ICENode): this;
@@ -71,6 +75,7 @@ export declare class ICENode extends ICEEventDispatcher {
     toJSON(): ICESerializedNode;
     dispose(): void;
     private getRoot;
+    private markSceneChanged;
     private isAncestorOf;
     private localMatrix;
 }

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

@@ -0,0 +1,2 @@
+export declare function colorToRgba(color: string): readonly [number, number, number, number];
+//# sourceMappingURL=Color.d.ts.map

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

@@ -19,7 +19,7 @@ export declare class FakeRendererBackend implements ICERendererBackend {
     prepareBatchGeometry(): void;
     releaseBatchGeometry(): void;
     render(frame: ICEFrame): void;
-    pick(): string | undefined;
+    pick(): Promise<string | undefined>;
     dispose(): void;
     get disposeCount(): number;
     private assertActive;

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

@@ -0,0 +1,14 @@
+import type { ICEBasicMaterial, ICEGeometry } from '../core/index.js';
+import type { ICEGeometryRenderable } from './Renderables.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 declare function collectInstanceBatches(renderables: readonly ICEGeometryRenderable[], output?: ICEInstanceBatch[]): readonly ICEInstanceBatch[];
+//# sourceMappingURL=InstanceBatch.d.ts.map

package/dist/_types/renderer/RenderBatch.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=RenderBatch.d.ts.map

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

@@ -0,0 +1,9 @@
+import { ICEMesh, type ICEScene } from '../core/index.js';
+export interface ICEGeometryRenderable {
+    readonly id: string;
+    readonly mesh: ICEMesh;
+    readonly worldMatrix: Float32Array;
+}
+export declare function collectRenderables(scene: ICEScene, output?: ICEGeometryRenderable[]): readonly ICEGeometryRenderable[];
+export declare const selectionIdentity: (mesh: ICEMesh) => string;
+//# sourceMappingURL=Renderables.d.ts.map

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

@@ -0,0 +1,19 @@
+export type ICEFrameStageProfile = Readonly<{
+    collectMs: number;
+    prepareAndUploadMs: number;
+    encodeMs: number;
+    submitMs: number;
+}>;
+type Stage = 'collect' | 'prepareAndUpload' | 'encode' | 'submit';
+export declare class RendererProfiler {
+    private enabled;
+    private cursor;
+    private readonly marks;
+    enable(value: boolean): void;
+    get isEnabled(): boolean;
+    begin(): void;
+    mark(stage: Stage): void;
+    end(): ICEFrameStageProfile | null;
+}
+export {};
+//# sourceMappingURL=RendererProfiler.d.ts.map

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

@@ -0,0 +1,12 @@
+import type { ICE3RendererPreference, ICE3RendererSelection, ICERendererBackend } from './types.js';
+export type ICERendererFactories = Readonly<{
+    createWebGPU: () => Promise<ICERendererBackend>;
+    createWebGL2: () => ICERendererBackend;
+}>;
+export type ICERendererBackendSelection = Readonly<{
+    backend: ICERendererBackend;
+    selection: ICE3RendererSelection;
+}>;
+export declare function selectRendererBackend(preference: ICE3RendererPreference, factories: ICERendererFactories): Promise<ICERendererBackendSelection>;
+export declare function selectDefaultRendererBackend(preference: ICE3RendererPreference): Promise<ICERendererBackendSelection>;
+//# sourceMappingURL=RendererSelection.d.ts.map

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

@@ -1,10 +1,3 @@
-import { ICEMesh, type ICEScene } from '../core/index.js';
-export interface ICEGeometryRenderable {
-    readonly id: string;
-    readonly mesh: ICEMesh;
-    readonly worldMatrix: Float32Array;
-}
-export declare function collectRenderables(scene: ICEScene, output?: ICEGeometryRenderable[]): readonly ICEGeometryRenderable[];
-export declare const selectionIdentity: (mesh: ICEMesh) => string;
-export { collectRenderBatches, semanticSelectionId, type ICERenderBatchDraw, type ICERenderBatchNode, } from './WebGL2RenderBatch.js';
+export { collectRenderables, selectionIdentity, type ICEGeometryRenderable, } from './Renderables.js';
+export { collectRenderBatches, semanticSelectionId, type ICERenderBatchDraw, type ICERenderBatchNode, } from './RenderBatch.js';
 //# sourceMappingURL=WebGL2GeometryBatch.d.ts.map

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

@@ -1,17 +1,7 @@
-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;
-}
+import type { ICEInstanceBatch } from './InstanceBatch.js';
+export type { ICEGeometryRenderable } from './Renderables.js';
+export { collectInstanceBatches, type ICEInstanceBatch, } from './InstanceBatch.js';
 export interface WebGL2InstanceEntry {
     readonly vertexArray: WebGLVertexArrayObject;
     readonly matrixBuffer: WebGLBuffer;
@@ -37,5 +27,4 @@ export declare class WebGL2InstanceCache {
     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/WebGL2RenderBatch.d.ts

@@ -1,17 +1,2 @@
-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;
+export { collectRenderBatches, semanticSelectionId, type ICERenderBatchDraw, type ICERenderBatchNode, } from './RenderBatch.js';
 //# sourceMappingURL=WebGL2RenderBatch.d.ts.map

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

@@ -1,6 +1,7 @@
 import { type ICEGeometry } from '../core/index.js';
+import { type ICEFrameStageProfile } from './RendererProfiler.js';
 import type { ICERendererBackend, ICERendererCapabilities, ICEFrame, ICEScreenPoint, ICEViewport } from './types.js';
-export declare function colorToRgba(color: string): readonly [number, number, number, number];
+export { colorToRgba } from './Color.js';
 export declare class WebGL2RendererBackend implements ICERendererBackend {
     capabilities: Readonly<ICERendererCapabilities>;
     private canvas;
@@ -20,6 +21,8 @@ export declare class WebGL2RendererBackend implements ICERendererBackend {
     private readonly batchesScratch;
     private readonly instancesScratch;
     private readonly instancedMeshIds;
+    private readonly profiler;
+    private lastFrameProfile;
     private backgroundRgba;
     private frameStats;
     private readonly handleContextLost;
@@ -34,7 +37,11 @@ export declare class WebGL2RendererBackend implements ICERendererBackend {
     prepareBatchGeometry(geometry: ICEGeometry): void;
     releaseBatchGeometry(geometry: ICEGeometry): void;
     render(frame: ICEFrame): void;
-    pick(frame: ICEFrame, point: ICEScreenPoint): string | undefined;
+    enableProfiling(enabled: boolean): void;
+    get frameProfile(): ICEFrameStageProfile | null;
+    pick(frame: ICEFrame, point: ICEScreenPoint): Promise<string | undefined>;
+    capture(): Promise<Blob>;
+    finish(): Promise<void>;
     dispose(): void;
     getViewport(): ICEViewport;
     getDevicePixelRatio(): number;

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

@@ -0,0 +1,14 @@
+export declare class WebGPUBundleCache {
+    private readonly device;
+    private readonly format;
+    private key;
+    private bundle;
+    private recreations;
+    constructor(device: GPUDevice, format: GPUTextureFormat);
+    get(key: string, record: (encoder: GPURenderBundleEncoder) => void): GPURenderBundle;
+    get current(): GPURenderBundle | null;
+    get bundleRecreations(): number;
+    invalidate(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=WebGPUBundleCache.d.ts.map

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

@@ -0,0 +1,23 @@
+export type ICEWebGPUAccelerationTier = 'baseline' | 'storage' | 'gpu-driven';
+export declare const WEBGPU_STORAGE_DEFAULT = false;
+export declare const WEBGPU_GPU_DRIVEN_DEFAULT = false;
+export declare const WEBGPU_INSTANCE_VISIBILITY_THRESHOLD = 1024;
+export type ICEWebGPUOptimizationStats = Readonly<{
+    tier: ICEWebGPUAccelerationTier;
+    selectionMaskActive: boolean;
+    bundleActive: boolean;
+    storageActive: boolean;
+    visibilityActive: boolean;
+    instanceUploadBytes: number;
+    bundleRecreations: number;
+    timestampUnavailableReason?: string;
+}>;
+export type ICEWebGPUAcceleration = Readonly<{
+    tier: ICEWebGPUAccelerationTier;
+    storage: boolean;
+    visibility: boolean;
+    maxStorageBufferBindingSize: number;
+    minStorageBufferOffsetAlignment: number;
+}>;
+export declare function detectWebGPUAcceleration(device: GPUDevice): ICEWebGPUAcceleration;
+//# sourceMappingURL=WebGPUCapabilities.d.ts.map

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

@@ -0,0 +1,27 @@
+export type ICEWebGPUDrawUniform = Readonly<{
+    matrix: ArrayLike<number>;
+    color: readonly [number, number, number, number];
+    useVertexColor: boolean;
+    useInstancing: boolean;
+    semanticHighlight?: number;
+    useSemantic?: boolean;
+    selectionBase: number;
+    useSelectionMask: boolean;
+    pageBase?: number;
+    useIndirect?: boolean;
+}>;
+export declare class WebGPUDrawStorage {
+    private readonly minimumCapacity;
+    private uniformBuffer;
+    private capacity;
+    private generationValue;
+    private count;
+    constructor(minimumCapacity?: number);
+    begin(requiredDraws: number): void;
+    append(draw: ICEWebGPUDrawUniform): number;
+    get uniformData(): Float32Array;
+    get drawCount(): number;
+    get generation(): number;
+    private ensureCapacity;
+}
+//# sourceMappingURL=WebGPUDrawStorage.d.ts.map

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

@@ -0,0 +1,45 @@
+import { type ICEGeometry } from '../core/index.js';
+export interface WebGPUGeometryEntry {
+    readonly vertexBuffer: GPUBuffer;
+    readonly triangleIndexBuffer: GPUBuffer;
+    readonly edgeIndexBuffer: GPUBuffer | null;
+    readonly semanticBuffer: GPUBuffer | null;
+    readonly triangleCount: number;
+    readonly edgeCount: number;
+    readonly indexFormat: GPUIndexFormat;
+    readonly vertexCount: number;
+    readonly bytes: number;
+    lastUsedFrame: number;
+}
+export interface WebGPUGeometryCacheOptions {
+    readonly device: GPUDevice;
+    readonly inactiveGraceFrames?: number;
+    readonly maxBytes?: number;
+}
+export declare class WebGPUGeometryCache {
+    private readonly device;
+    private readonly entries;
+    private active;
+    private readonly pinned;
+    private readonly inactiveGraceFrames;
+    private readonly maxBytes;
+    private uploads;
+    private evictions;
+    private frameId;
+    private resourceGeneration;
+    constructor(options: WebGPUGeometryCacheOptions);
+    retain(geometry: ICEGeometry): WebGPUGeometryEntry;
+    pin(geometry: ICEGeometry): WebGPUGeometryEntry;
+    unpin(geometry: ICEGeometry): void;
+    beginFrame(): void;
+    endFrame(): void;
+    clear(): void;
+    dispose(): void;
+    get totalBytes(): number;
+    get uploadCount(): number;
+    get evictionCount(): number;
+    get generation(): number;
+    private enforceBudget;
+    private deleteEntry;
+}
+//# sourceMappingURL=WebGPUGeometryCache.d.ts.map

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

@@ -0,0 +1,24 @@
+import type { ICEInstanceBatch } from './InstanceBatch.js';
+export interface WebGPUInstanceEntry {
+    readonly matrixBuffer: GPUBuffer;
+    readonly semanticBuffer: GPUBuffer;
+    instanceCount: number;
+    readonly bytes: number;
+    readonly generation: number;
+}
+export declare class WebGPUInstanceCache {
+    private readonly device;
+    private readonly entries;
+    private active;
+    private bufferGeneration;
+    constructor(device: GPUDevice);
+    retain(batch: ICEInstanceBatch): WebGPUInstanceEntry;
+    beginFrame(): void;
+    endFrame(): void;
+    clear(): void;
+    dispose(): void;
+    get totalBytes(): number;
+    get generation(): number;
+    private deleteEntry;
+}
+//# sourceMappingURL=WebGPUInstanceCache.d.ts.map

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

@@ -0,0 +1,39 @@
+import type { ICEGeometry } from '../core/index.js';
+import type { ICEInstanceBatch } from './InstanceBatch.js';
+export declare const INSTANCE_RECORD_BYTES = 96;
+export type ICEInstanceStoragePagePlan = Readonly<{
+    firstInstance: number;
+    instanceCount: number;
+}>;
+export type ICEInstanceStoragePage = ICEInstanceStoragePagePlan & {
+    readonly buffer: GPUBuffer;
+};
+export type ICEInstanceStorageEntry = Readonly<{
+    pages: readonly ICEInstanceStoragePage[];
+    generation: number;
+    bytes: number;
+}>;
+export type WebGPUInstanceStorageOptions = {
+    readonly maxBindingBytes: number;
+    readonly minOffsetAlignment: number;
+};
+export declare class WebGPUInstanceStorage {
+    private readonly device;
+    private readonly entries;
+    private active;
+    private resourceGeneration;
+    private uploadBytes;
+    private readonly maxBindingBytes;
+    private readonly minOffsetAlignment;
+    constructor(device: GPUDevice, options?: Partial<WebGPUInstanceStorageOptions>);
+    plan(instanceCount: number, recordBytes?: number): readonly ICEInstanceStoragePagePlan[];
+    retain(batch: ICEInstanceBatch, geometry: ICEGeometry): ICEInstanceStorageEntry;
+    beginFrame(): void;
+    endFrame(): void;
+    get generation(): number;
+    get totalBytes(): number;
+    get totalUploadBytes(): number;
+    dispose(): void;
+    private delete;
+}
+//# sourceMappingURL=WebGPUInstanceStorage.d.ts.map

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

@@ -0,0 +1,30 @@
+import { WebGPUGeometryCache } from './WebGPUGeometryCache.js';
+import type { ICEFrame, ICEScreenPoint } from './types.js';
+type ICEPickFrame = ICEFrame & {
+    readonly point: ICEScreenPoint;
+};
+export declare class WebGPUPicker {
+    private readonly device;
+    private readonly pipelinePromise;
+    private readonly instanceCache;
+    private readonly identityInstances;
+    private readonly zeroSemantics;
+    private readonly renderPlan;
+    private target;
+    private depth;
+    private uniformBuffer;
+    private width;
+    private height;
+    private disposed;
+    constructor(device: GPUDevice, format: GPUTextureFormat);
+    pick(frame: ICEPickFrame, geometryCache: WebGPUGeometryCache, pickIds: Readonly<Record<number, string>>): Promise<string | undefined>;
+    resize(width: number, height: number): void;
+    dispose(): void;
+    private ensureTarget;
+    private ensureUniformBuffer;
+    private uniformBufferCapacity;
+    private uniformBufferDraws;
+}
+export declare function collectWebGPUPickIds(frame: ICEFrame): Readonly<Record<number, string>>;
+export {};
+//# sourceMappingURL=WebGPUPicker.d.ts.map

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

@@ -0,0 +1,21 @@
+export type ICEWebGPUProbeFailureReason = 'document-unavailable' | 'api-unavailable' | 'adapter-unavailable' | 'adapter-timeout' | 'feature-missing' | 'limit-too-low' | 'device-failed' | 'context-failed' | 'pipeline-failed' | 'device-lost';
+export type ICEWebGPUProbeResult = {
+    readonly supported: true;
+    readonly adapter: GPUAdapter;
+    readonly device: GPUDevice;
+    readonly format: GPUTextureFormat;
+    readonly enabledFeatures: ReadonlySet<GPUFeatureName>;
+    readonly release: () => void;
+} | {
+    readonly supported: false;
+    readonly reason: ICEWebGPUProbeFailureReason;
+    readonly detail?: string;
+};
+export type ICEWebGPUProbeOptions = {
+    readonly gpu?: GPU;
+    readonly timeoutMs?: number;
+    readonly createCanvas?: () => OffscreenCanvas | HTMLCanvasElement;
+    readonly optionalFeatures?: readonly GPUFeatureName[];
+};
+export declare function probeWebGPU(options?: ICEWebGPUProbeOptions): Promise<ICEWebGPUProbeResult>;
+//# sourceMappingURL=WebGPUProbe.d.ts.map

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

@@ -0,0 +1,22 @@
+export declare const WEBGPU_UNIFORM_STRIDE = 256;
+export declare const WEBGPU_UNIFORM_BYTES = 128;
+export declare class WebGPURenderPipeline {
+    readonly device: GPUDevice;
+    readonly format: GPUTextureFormat;
+    readonly bindGroupLayout: GPUBindGroupLayout;
+    readonly pipelineLayout: GPUPipelineLayout;
+    readonly triangle: GPURenderPipeline;
+    readonly line: GPURenderPipeline;
+    readonly selectionTriangle: GPURenderPipeline;
+    readonly selectionLine: GPURenderPipeline;
+    readonly selectionMask: boolean;
+    readonly storageInstances: boolean;
+    readonly indirectInstances: boolean;
+    private constructor();
+    static create(device: GPUDevice, format: GPUTextureFormat, options?: {
+        readonly selectionMask?: boolean;
+        readonly storageInstances?: boolean;
+        readonly indirectInstances?: boolean;
+    }): Promise<WebGPURenderPipeline>;
+}
+//# sourceMappingURL=WebGPURenderPipeline.d.ts.map

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

@@ -0,0 +1,23 @@
+import type { ICEScene } from '../core/index.js';
+import { type ICEGeometryRenderable } from './Renderables.js';
+import { type ICEInstanceBatch } from './InstanceBatch.js';
+import { type ICERenderBatchDraw } from './RenderBatch.js';
+export type WebGPURenderPlan = Readonly<{
+    scene: ICEScene;
+    revision: number;
+    renderables: readonly ICEGeometryRenderable[];
+    instances: readonly ICEInstanceBatch[];
+    batches: readonly ICERenderBatchDraw[];
+    instancedMeshIds: ReadonlySet<string>;
+}>;
+export declare class WebGPURenderPlanCache {
+    private scene;
+    private current;
+    private readonly renderablesScratch;
+    private readonly instancesScratch;
+    private readonly batchesScratch;
+    get(scene: ICEScene): WebGPURenderPlan;
+    invalidate(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=WebGPURenderPlan.d.ts.map

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

@@ -0,0 +1,111 @@
+import { ICEEngineError, type ICEGeometry } from '../core/index.js';
+import type { ICERendererBackend, ICERendererCapabilities, ICEFrame, ICEViewport } from './types.js';
+import { type ICEFrameStageProfile } from './RendererProfiler.js';
+import { type ICEWebGPUOptimizationStats } from './WebGPUCapabilities.js';
+import type { ICEScreenPoint } from './types.js';
+export type WebGPUDeviceContext = Readonly<{
+    adapter: GPUAdapter;
+    device: GPUDevice;
+    format: GPUTextureFormat;
+    release?: () => void;
+}>;
+export type WebGPURendererBackendOptions = Readonly<{
+    readonly forceStoragePath?: boolean;
+    readonly forceGpuDriven?: boolean;
+}>;
+export declare class WebGPURendererBackend implements ICERendererBackend {
+    capabilities: Readonly<ICERendererCapabilities>;
+    private readonly adapter;
+    private device;
+    private readonly format;
+    private pipeline;
+    private storagePipeline;
+    private gpuDrivenPipeline;
+    private visibilityEncoder;
+    private storageCache;
+    private readonly acceleration;
+    private readonly forceStoragePath;
+    private readonly forceGpuDriven;
+    private readonly releaseProbe;
+    private onContextLost;
+    private onContextRestored;
+    private onError;
+    private disposing;
+    private canvas;
+    private context;
+    private geometryCache;
+    private instanceCache;
+    private picker;
+    private selectionMaskBuffer;
+    private timestampProfiler;
+    private timestampProfilingEnabled;
+    private bundleCache;
+    private bundleActive;
+    private frameBindGroup;
+    private frameBindGroupKey;
+    private readonly storageBindGroups;
+    private uniformBufferGeneration;
+    private readonly optimizationWarnings;
+    private identityInstances;
+    private zeroSemantics;
+    private uniformBuffer;
+    private depthTexture;
+    private uniformCapacity;
+    private viewport;
+    private dpr;
+    private backgroundRgba;
+    private frameStats;
+    private lastFrame;
+    private captureRequest;
+    private readonly renderPlan;
+    private readonly drawListScratch;
+    private readonly selected;
+    private readonly drawStorage;
+    private readonly lastVisibilityEntries;
+    private readonly mvpScratch;
+    private readonly worldScratch;
+    private readonly profiler;
+    private lastFrameProfile;
+    private optimizationFailureReason;
+    private storageFailureReason;
+    private visibilityFailureReason;
+    private constructor();
+    static create(context: WebGPUDeviceContext, options?: WebGPURendererBackendOptions): Promise<WebGPURendererBackend>;
+    initialize(options: {
+        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;
+    render(frame: ICEFrame): void;
+    enableProfiling(enabled: boolean): void;
+    get frameProfile(): ICEFrameStageProfile | null;
+    pick(frame: ICEFrame, point: ICEScreenPoint): Promise<string | undefined>;
+    dispose(): void;
+    capture(): Promise<Blob>;
+    finish(): Promise<void>;
+    drainGpuTimings(): Promise<readonly number[]>;
+    enableTimestampProfiling(enabled: boolean): void;
+    get timestampProfilingAvailable(): boolean;
+    get timestampProfilingUnavailableReason(): string | undefined;
+    get stats(): Readonly<typeof this.frameStats>;
+    readVisibilityStats(): Promise<Readonly<{
+        visibleInstances: number;
+        culledInstances: number;
+        dispatchCount: number;
+    }> | undefined>;
+    get storageActive(): boolean;
+    private get gpuDrivenActive();
+    get optimizationStats(): ICEWebGPUOptimizationStats;
+    private storageBindGroupFor;
+    private reportOptimizationFailure;
+    private requireGeometryCache;
+    private ensureUniformCapacity;
+    private watchDevice;
+    private recoverDevice;
+}
+//# sourceMappingURL=WebGPURendererBackend.d.ts.map

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

@@ -0,0 +1,9 @@
+export declare const WEBGPU_BUFFER_USAGE: {
+    readonly vertex: number;
+    readonly index: number;
+};
+export declare function alignToFourBytes(value: number): number;
+export declare function createGPUDataBuffer(device: GPUDevice, data: ArrayBufferView, usage: GPUBufferUsageFlags, label: string): GPUBuffer;
+export declare function createEmptyGPUDataBuffer(device: GPUDevice, byteLength: number, usage: GPUBufferUsageFlags, label: string): GPUBuffer;
+export declare function writeGPUData(device: GPUDevice, buffer: GPUBuffer, data: ArrayBufferView): void;
+//# sourceMappingURL=WebGPUResources.d.ts.map

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

@@ -0,0 +1,18 @@
+export type ICESelectionMaskLayout = Readonly<{
+    words: Uint32Array;
+    bases: readonly number[];
+}>;
+export declare function buildSelectionMask(ranges: readonly (readonly string[])[], selection: readonly string[]): ICESelectionMaskLayout;
+export declare class WebGPUSelectionMaskBuffer {
+    private readonly device;
+    private maskBuffer;
+    private previous;
+    private maskGeneration;
+    constructor(device: GPUDevice);
+    get buffer(): GPUBuffer | null;
+    get generation(): number;
+    get totalBytes(): number;
+    update(words: Uint32Array): void;
+    dispose(): void;
+}
+//# sourceMappingURL=WebGPUSelectionMask.d.ts.map