ice3 0.2.0 → 0.2.1

package/dist/_types/assets/ICEPreparedGLB.d.ts

@@ -21,6 +21,7 @@ export interface ICEPreparedMaterial {
     readonly id: string;
     readonly baseColor: string;
     readonly edgeColor?: string;
+    readonly shading?: 'directional' | 'flat' | 'water';
 }
 export interface ICEPreparedMesh {
     readonly id: string;

package/dist/_types/assets/ICEPreviewGeometryPacket.d.ts

@@ -0,0 +1,60 @@
+export type ICEPreviewGeometryBackend = 'cpu' | 'gpu';
+export type ICEPreviewGeometryResidencyMode = 'cpu' | 'cold' | 'warm' | 'resident' | 'snapshot';
+export type ICEPreviewGeometryRangeUsage = 'vertex_attributes' | 'indices';
+export interface ICEPreviewGeometryRange {
+    readonly byteOffset: number;
+    readonly byteLength: number;
+    readonly usage: ICEPreviewGeometryRangeUsage;
+}
+export interface ICEPreviewGeometryNode {
+    readonly nodeId: string;
+    readonly parentId: string | null;
+    readonly name: string;
+    readonly matrix: readonly number[];
+    readonly materialId: string | null;
+    readonly geometryId: string | null;
+    readonly visible: boolean;
+}
+export interface ICEPreviewGeometryRecord {
+    readonly geometryId: string;
+    readonly residentGeometryId: string | null;
+    readonly topologyDigest: string;
+    readonly attributeDigest: string;
+    readonly vertexCount: number;
+    readonly indexCount: number;
+    readonly indexWidth: 2 | 4;
+    readonly ranges: readonly ICEPreviewGeometryRange[];
+}
+export interface ICEPreviewGeometry extends ICEPreviewGeometryRecord {
+    readonly positions: Float32Array;
+    readonly indices: Uint16Array | Uint32Array;
+}
+export interface ICEPreviewGeometryMaterial {
+    readonly materialId: string;
+    readonly baseColor: readonly [number, number, number, number];
+    readonly metallic: number;
+    readonly roughness: number;
+    readonly opacity: number;
+}
+export interface ICEPreviewGeometryManifest {
+    readonly schemaVersion: number;
+    readonly transportVersion: number;
+    readonly revision: number;
+    readonly parentRevision: number | null;
+    readonly sourceDigest: string;
+    readonly backend: ICEPreviewGeometryBackend;
+    readonly residencyMode: ICEPreviewGeometryResidencyMode;
+    readonly nodes: readonly ICEPreviewGeometryNode[];
+    readonly geometries: readonly ICEPreviewGeometryRecord[];
+    readonly materials: readonly ICEPreviewGeometryMaterial[];
+    readonly removedNodeIds: readonly string[];
+    readonly removedGeometryIds: readonly string[];
+}
+export interface ICEPreviewGeometryPacket extends Omit<ICEPreviewGeometryManifest, 'geometries'> {
+    readonly geometries: readonly ICEPreviewGeometry[];
+    readonly binary: Uint8Array;
+}
+export type ICEPreviewGeometryDelta = ICEPreviewGeometryPacket;
+export declare function parsePreviewGeometryPacket(input: Uint8Array | ArrayBuffer): ICEPreviewGeometryPacket;
+export declare function applyPreviewGeometryDelta(base: ICEPreviewGeometryPacket, delta: ICEPreviewGeometryDelta): ICEPreviewGeometryPacket;
+//# sourceMappingURL=ICEPreviewGeometryPacket.d.ts.map

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

@@ -1,5 +1,7 @@
 export { readPreparedGLB, verifyPreparedGLBIntegrity, } from './ICEGLBReader.js';
 export type { ICEPreparedAssetSnapshot, ICEPreparedBatch, ICEPreparedBatching, ICEPreparedContract, ICEPreparedGeometry, ICEPreparedMaterial, ICEPreparedMesh, ICEPreparedNode, ICEPreparedStats, } from './ICEPreparedGLB.js';
+export { applyPreviewGeometryDelta, parsePreviewGeometryPacket, } from './ICEPreviewGeometryPacket.js';
+export type { ICEPreviewGeometry, ICEPreviewGeometryBackend, ICEPreviewGeometryDelta, ICEPreviewGeometryManifest, ICEPreviewGeometryMaterial, ICEPreviewGeometryNode, ICEPreviewGeometryPacket, ICEPreviewGeometryRange, ICEPreviewGeometryRangeUsage, ICEPreviewGeometryRecord, ICEPreviewGeometryResidencyMode, } from './ICEPreviewGeometryPacket.js';
 export { readTileset } from './ICETilesetReader.js';
 export type { ICETilesetSnapshot, ICETilesetTile, } from './ICETileset.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/_types/core/camera/ICEPerspectiveCamera.d.ts

@@ -11,13 +11,14 @@ export interface ICEPerspectiveCameraOptions {
 export declare class ICEPerspectiveCamera {
     readonly id: string;
     readonly fov: number;
-    readonly near: number;
-    readonly far: number;
+    near: number;
+    far: number;
     private eye;
     private lookTarget;
     constructor(options: ICEPerspectiveCameraOptions);
     setPosition(position: ICEVector3Tuple): this;
     setTarget(target: ICEVector3Tuple): this;
+    setClipPlanes(near: number, far: number): this;
     getPosition(): ICEVector3;
     getTarget(): ICEVector3;
     getViewProjectionMatrix(aspect: number): ICEMatrix4;

package/dist/_types/core/geometry/ICEGeometry.d.ts

@@ -2,6 +2,18 @@ export interface ICEGeometryBounds {
     readonly min: readonly [number, number, number];
     readonly max: readonly [number, number, number];
 }
+export interface ICEGeometryIdentity {
+    readonly geometryId: string;
+    readonly topologyDigest: string;
+    readonly attributeDigest: string;
+}
+export interface ICEGeometryByteRange {
+    readonly byteOffset: number;
+    readonly byteLength: number;
+}
+export interface ICEGeometryBufferUpdate {
+    readonly positionRanges: readonly ICEGeometryByteRange[];
+}
 export interface ICEGeometry {
     readonly typeId: string;
     readonly positions: Float32Array;
@@ -9,6 +21,7 @@ export interface ICEGeometry {
     readonly edgeIndices?: Uint16Array | Uint32Array;
     readonly colors?: Float32Array;
     readonly semanticIndices?: Uint32Array;
+    readonly identity?: ICEGeometryIdentity;
     getBounds(): ICEGeometryBounds;
     toJSON(): Record<string, unknown>;
 }

package/dist/_types/core/geometry/ICEIndexedGeometry.d.ts

@@ -1,4 +1,4 @@
-import type { ICEGeometry, ICEGeometryBounds } from './ICEGeometry.js';
+import type { ICEGeometry, ICEGeometryBounds, ICEGeometryIdentity } from './ICEGeometry.js';
 export interface ICEIndexedGeometryOptions {
     readonly id: string;
     readonly positions: Float32Array;
@@ -6,6 +6,7 @@ export interface ICEIndexedGeometryOptions {
     readonly edgeIndices?: Uint16Array | Uint32Array;
     readonly colors?: Float32Array;
     readonly semanticIndices?: Uint32Array;
+    readonly identity?: ICEGeometryIdentity;
 }
 export declare class ICEIndexedGeometry implements ICEGeometry {
     readonly typeId = "ice3:IndexedGeometry";
@@ -15,6 +16,7 @@ export declare class ICEIndexedGeometry implements ICEGeometry {
     readonly edgeIndices?: Uint16Array | Uint32Array;
     readonly colors?: Float32Array;
     readonly semanticIndices?: Uint32Array;
+    readonly identity: ICEGeometryIdentity;
     constructor(options: ICEIndexedGeometryOptions);
     getBounds(): ICEGeometryBounds;
     toJSON(): Record<string, unknown>;

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

@@ -7,7 +7,7 @@ export { ICEBoxGeometry } from './geometry/ICEBoxGeometry.js';
 export type { ICEBoxGeometryOptions } from './geometry/ICEBoxGeometry.js';
 export { ICEIndexedGeometry } from './geometry/ICEIndexedGeometry.js';
 export type { ICEIndexedGeometryOptions } from './geometry/ICEIndexedGeometry.js';
-export type { ICEGeometry, ICEGeometryBounds } from './geometry/ICEGeometry.js';
+export type { ICEGeometry, ICEGeometryBounds, ICEGeometryBufferUpdate, ICEGeometryByteRange, ICEGeometryIdentity, } from './geometry/ICEGeometry.js';
 export { ICEBasicMaterial } from './material/ICEBasicMaterial.js';
 export type { ICEBasicMaterialOptions } from './material/ICEBasicMaterial.js';
 export { ICEPerspectiveCamera } from './camera/ICEPerspectiveCamera.js';

package/dist/_types/core/material/ICEBasicMaterial.d.ts

@@ -1,11 +1,13 @@
 export interface ICEBasicMaterialOptions {
     readonly color: string;
     readonly edgeColor?: string;
+    readonly shading?: 'directional' | 'flat' | 'water';
 }
 export declare class ICEBasicMaterial {
     readonly typeId = "ice3:BasicMaterial";
     readonly color: string;
     readonly edgeColor: string | undefined;
+    readonly shading: 'directional' | 'flat' | 'water' | undefined;
     constructor(options: ICEBasicMaterialOptions);
     toJSON(): Record<string, unknown>;
 }

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

@@ -1,5 +1,9 @@
-import type { ICEGeometry } from '../core/index.js';
+import type { ICEGeometry, ICEGeometryBufferUpdate } from '../core/index.js';
 export interface GeometryEntry {
+    geometry: ICEGeometry;
+    readonly geometryId: string;
+    readonly attributeDigest: string;
+    readonly topologyDigest: string;
     readonly vertexArray: WebGLVertexArrayObject;
     readonly positionBuffer: WebGLBuffer;
     readonly triangleIndexBuffer: WebGLBuffer;
@@ -19,24 +23,34 @@ export declare class WebGL2GeometryCache {
     private readonly entries;
     private active;
     private readonly pinned;
+    private readonly objectKeys;
+    private readonly legacyKeys;
+    private objectKeySequence;
     private gl;
     private uploads;
+    private updatedBytes;
     private evictions;
     private frameId;
     private readonly inactiveGraceFrames;
     private readonly maxBytes;
     constructor(options?: WebGL2GeometryCacheOptions);
     retain(gl: WebGL2RenderingContext, geometry: ICEGeometry): Readonly<GeometryEntry>;
+    private createEntry;
     beginFrame(): void;
-    pin(gl: WebGL2RenderingContext, geometry: ICEGeometry): Readonly<GeometryEntry>;
+    pin(gl: WebGL2RenderingContext, geometry: ICEGeometry, update?: ICEGeometryBufferUpdate): Readonly<GeometryEntry>;
     unpin(geometry: ICEGeometry): void;
     endFrame(): void;
     clear(): void;
     dispose(): void;
     get totalBytes(): number;
     get uploadCount(): number;
+    get updateBytes(): number;
     get evictionCount(): number;
     private deleteEntry;
     private enforceBudget;
+    private applyPositionUpdate;
+    private canReuse;
+    private sameTopology;
+    private keyFor;
 }
 //# sourceMappingURL=WebGL2GeometryCache.d.ts.map

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

@@ -1,4 +1,5 @@
 import type { ICEMatrix4 } from '../core/index.js';
+export declare function directionalLightingShade(normal: readonly [number, number, number]): number;
 export declare class WebGL2Program {
     private readonly gl;
     static readonly POSITION_ATTRIBUTE = 0;
@@ -10,14 +11,27 @@ export declare class WebGL2Program {
     private readonly colorLocation;
     private readonly clipOffsetLocation;
     private readonly vertexColorLocation;
+    private readonly directionalShadingLocation;
+    private readonly waterShadingLocation;
+    private readonly cameraPositionLocation;
+    private readonly shadowMapLocation;
+    private readonly lightMatrixLocation;
+    private readonly shadowEnabledLocation;
     private readonly instancingLocation;
+    private readonly pickModeLocation;
     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;
+    /** 绑定阴影贴图与光源矩阵；关闭时着色器跳过采样。 */
+    setShadow(enabled: boolean, texture: WebGLTexture | null, matrix: Float32Array | null, unit?: number): void;
+    setDirectionalShading(enabled: boolean): void;
+    setWaterShading(enabled: boolean): void;
+    setCameraPosition(position: readonly [number, number, number]): void;
     setInstancing(enabled: boolean): void;
+    setPickMode(enabled: boolean): void;
     dispose(): void;
     private createProgram;
     private compile;

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

@@ -11,6 +11,8 @@ export declare class WebGL2RendererBackend implements ICERendererBackend {
     private onContextLost;
     private onContextRestored;
     private program;
+    private shadowMap;
+    private readonly shadowEnabled;
     private semanticProgram;
     private geometryCache;
     private instanceCache;
@@ -35,6 +37,8 @@ export declare class WebGL2RendererBackend implements ICERendererBackend {
     resize(viewport: ICEViewport, dpr: number): void;
     setBackgroundColor(color: string): void;
     prepareBatchGeometry(geometry: ICEGeometry): void;
+    prepareGeometry(geometry: ICEGeometry, update?: import('../core/index.js').ICEGeometryBufferUpdate): void;
+    releaseGeometry(geometry: ICEGeometry): void;
     releaseBatchGeometry(geometry: ICEGeometry): void;
     render(frame: ICEFrame): void;
     enableProfiling(enabled: boolean): void;

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

@@ -0,0 +1,26 @@
+/** 光源方向（与主着色器的 diffuse 保持同一方向）。 */
+export declare const LIGHT_DIRECTION: readonly [number, number, number];
+export declare class WebGL2ShadowMap {
+    private readonly gl;
+    private framebuffer;
+    private depthTexture;
+    private program;
+    private lightMatrixLocation;
+    private matrixScratch;
+    constructor(gl: WebGL2RenderingContext);
+    /** 深度纹理，供主着色器采样。 */
+    get texture(): WebGLTexture | null;
+    get matrix(): Float32Array;
+    /** 绑定阴影帧缓冲，返回是否成功。 */
+    begin(): boolean;
+    /** 解绑，恢复默认帧缓冲。 */
+    end(width: number, height: number): void;
+    dispose(): void;
+    private createResources;
+    /** 正交光源矩阵：覆盖整片场地，与主着色器的光方向一致。 */
+    private updateLightMatrix;
+    private createProgram;
+    private compile;
+}
+export declare const SHADOW_BIAS = 0.0018;
+//# sourceMappingURL=WebGL2ShadowMap.d.ts.map

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

@@ -3,6 +3,7 @@ export type ICEWebGPUDrawUniform = Readonly<{
     color: readonly [number, number, number, number];
     useVertexColor: boolean;
     useInstancing: boolean;
+    useLighting?: boolean;
     semanticHighlight?: number;
     useSemantic?: boolean;
     selectionBase: number;

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

@@ -1,5 +1,9 @@
-import { type ICEGeometry } from '../core/index.js';
+import { type ICEGeometry, type ICEGeometryBufferUpdate } from '../core/index.js';
 export interface WebGPUGeometryEntry {
+    geometry: ICEGeometry;
+    readonly geometryId: string;
+    readonly attributeDigest: string;
+    readonly topologyDigest: string;
     readonly vertexBuffer: GPUBuffer;
     readonly triangleIndexBuffer: GPUBuffer;
     readonly edgeIndexBuffer: GPUBuffer | null;
@@ -21,15 +25,20 @@ export declare class WebGPUGeometryCache {
     private readonly entries;
     private active;
     private readonly pinned;
+    private readonly objectKeys;
+    private readonly legacyKeys;
+    private objectKeySequence;
     private readonly inactiveGraceFrames;
     private readonly maxBytes;
     private uploads;
+    private updatedBytes;
     private evictions;
     private frameId;
     private resourceGeneration;
     constructor(options: WebGPUGeometryCacheOptions);
     retain(geometry: ICEGeometry): WebGPUGeometryEntry;
-    pin(geometry: ICEGeometry): WebGPUGeometryEntry;
+    private createEntry;
+    pin(geometry: ICEGeometry, update?: ICEGeometryBufferUpdate): WebGPUGeometryEntry;
     unpin(geometry: ICEGeometry): void;
     beginFrame(): void;
     endFrame(): void;
@@ -37,9 +46,14 @@ export declare class WebGPUGeometryCache {
     dispose(): void;
     get totalBytes(): number;
     get uploadCount(): number;
+    get updateBytes(): number;
     get evictionCount(): number;
     get generation(): number;
     private enforceBudget;
     private deleteEntry;
+    private applyPositionUpdate;
+    private canReuse;
+    private sameTopology;
+    private keyFor;
 }
 //# sourceMappingURL=WebGPUGeometryCache.d.ts.map

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

@@ -1,5 +1,5 @@
 export declare const WEBGPU_UNIFORM_STRIDE = 256;
-export declare const WEBGPU_UNIFORM_BYTES = 128;
+export declare const WEBGPU_UNIFORM_BYTES = 144;
 export declare class WebGPURenderPipeline {
     readonly device: GPUDevice;
     readonly format: GPUTextureFormat;

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

@@ -80,6 +80,8 @@ export declare class WebGPURendererBackend implements ICERendererBackend {
     resize(viewport: ICEViewport, dpr: number): void;
     setBackgroundColor(color: string): void;
     prepareBatchGeometry(geometry: ICEGeometry): void;
+    prepareGeometry(geometry: ICEGeometry, update?: import('../core/index.js').ICEGeometryBufferUpdate): void;
+    releaseGeometry(geometry: ICEGeometry): void;
     releaseBatchGeometry(geometry: ICEGeometry): void;
     render(frame: ICEFrame): void;
     enableProfiling(enabled: boolean): void;

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

@@ -1,4 +1,4 @@
-import type { ICEGeometry, ICEEngineError, ICEPerspectiveCamera, ICEScene } from '../core/index.js';
+import type { ICEGeometry, ICEGeometryBufferUpdate, ICEEngineError, ICEPerspectiveCamera, ICEScene } from '../core/index.js';
 export type ICEViewport = {
     readonly x: number;
     readonly y: number;
@@ -54,6 +54,8 @@ export interface ICERendererBackend {
     setBackgroundColor?(color: string): void;
     prepareBatchGeometry?(geometry: ICEGeometry): void;
     releaseBatchGeometry?(geometry: ICEGeometry): void;
+    prepareGeometry?(geometry: ICEGeometry, update?: ICEGeometryBufferUpdate): void;
+    releaseGeometry?(geometry: ICEGeometry): void;
     pick?(frame: ICEFrame, point: ICEScreenPoint): Promise<string | undefined>;
     render(frame: ICEFrame): void;
     finish?(): Promise<void>;

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

@@ -98,6 +98,8 @@ export declare class ICE3 extends ICEEventDispatcher {
     setBackgroundColor(color: string): this;
     prepareRenderBatchGeometry(geometry: ICEGeometry): this;
     releaseRenderBatchGeometry(geometry: ICEGeometry): this;
+    prepareGeometry(geometry: ICEGeometry, update?: import('../core/index.js').ICEGeometryBufferUpdate): this;
+    releaseGeometry(geometry: ICEGeometry): this;
     addLayer(layer: ICE2DLayer): this;
     removeLayer(layer: ICE2DLayer): this;
     start(): this;

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

@@ -1,9 +1,15 @@
-import type { ICEPreparedAssetSnapshot, ICEPreparedStats } from '../../assets/index.js';
-import { ICEScene, type ICEGeometryBounds } from '../../core/index.js';
+import type { ICEPreparedAssetSnapshot, ICEPreparedStats, ICEPreviewGeometryPacket } from '../../assets/index.js';
+import { ICEIndexedGeometry, ICEScene, type ICEGeometryBounds, type ICEGeometryBufferUpdate } from '../../core/index.js';
 export interface ICEBuiltAsset {
     readonly scene: ICEScene;
     readonly bounds: ICEGeometryBounds;
     readonly stats: ICEPreparedStats;
 }
+export interface ICEBuiltPreviewPacket {
+    readonly scene: ICEScene;
+    readonly geometries: ReadonlyMap<string, ICEIndexedGeometry>;
+    readonly geometryUpdates: ReadonlyMap<string, ICEGeometryBufferUpdate>;
+}
 export declare function buildAssetScene(snapshot: ICEPreparedAssetSnapshot): ICEBuiltAsset;
+export declare function buildPreviewPacketScene(packet: ICEPreviewGeometryPacket, previousGeometries?: ReadonlyMap<string, ICEIndexedGeometry>): ICEBuiltPreviewPacket;
 //# sourceMappingURL=ICEAssetSceneBuilder.d.ts.map

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

@@ -0,0 +1,25 @@
+import { type ICEPreviewGeometryPacket } from '../../assets/index.js';
+import type { ICEGeometryBufferUpdate, ICEIndexedGeometry, ICEScene } from '../../core/index.js';
+export type ICEPreviewPacketFallbackReason = 'packet-unavailable' | 'packet-invalid' | 'packet-revision-mismatch';
+export type ICEPreviewPacketLoadResult = {
+    readonly kind: 'packet';
+    readonly packet: ICEPreviewGeometryPacket;
+} | {
+    readonly kind: 'fallback';
+    readonly reason: ICEPreviewPacketFallbackReason;
+};
+export interface ICEPreviewPacketLoaderOptions {
+    readonly fetch?: typeof fetch;
+    readonly pinGeometry?: (geometry: ICEIndexedGeometry, update?: ICEGeometryBufferUpdate) => void;
+}
+export declare class ICEPreviewPacketLoader {
+    private readonly fetcher;
+    private readonly pinGeometry;
+    private geometries;
+    private publishedScene;
+    constructor(options?: ICEPreviewPacketLoaderOptions | typeof fetch);
+    get scene(): ICEScene | null;
+    get currentGeometries(): ReadonlyMap<string, ICEIndexedGeometry>;
+    load(url: string, current?: ICEPreviewGeometryPacket): Promise<ICEPreviewPacketLoadResult>;
+}
+//# sourceMappingURL=ICEPreviewPacketLoader.d.ts.map

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

@@ -154,7 +154,6 @@ export declare class ICETilesetHandle extends ICEEventDispatcher {
     private enterCameraMotion;
     private promoteReadyVisibleTargets;
     private lodReadyVisibleCoverage;
-    private reconcileSelectionVisibility;
     private rejectReadyIfVisibleSetFailed;
     private updateBudgetWarning;
     private residentBudgetReached;

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

@@ -25,10 +25,11 @@ export { ICERenderBatch, type ICERenderBatchOptions, } from './asset/ICERenderBa
 export { ICEAssetLoader, type ICEAssetHandle, type ICEAssetLoaderOptions, type ICEAssetLoadOptions, } from './asset/ICEAssetLoader.js';
 export { ICETilesetHandle, ICETilesetLoader, type ICETilesetEvent, type ICETilesetLoaderOptions, type ICETilesetOpenOptions, type ICETilesetStats, type ICETilesetTileState, } from './asset/ICETilesetLoader.js';
 export { ICETilesetScheduler, type ICETilesetSchedulerOptions, type ICETilesetWorkSet, type ICETilesetWorkSetInput, } from './asset/ICETilesetScheduler.js';
+export { ICEPreviewPacketLoader, type ICEPreviewPacketFallbackReason, type ICEPreviewPacketLoadResult, type ICEPreviewPacketLoaderOptions, } from './asset/ICEPreviewPacketLoader.js';
 export { ICELodSelector, type ICELodSelection, type ICELodSelectionInput, } from './asset/ICELodSelector.js';
 export type { ICELodStats } from './asset/ICETilesetLoader.js';
 export { collectSceneItems, raycastSceneNode, type ICERay, type ICESceneItem, type ICESceneQuery, } from './query/ICESceneQuery.js';
-export type { ICEPreparedContract, ICEPreparedStats, } from '../assets/index.js';
+export type { ICEPreparedContract, ICEPreparedStats, ICEPreviewGeometryPacket, } from '../assets/index.js';
 export { ICEAdaptiveRenderBatchController, } from './batching/ICEAdaptiveRenderBatchController.js';
 export type { ICEAdaptiveBatchExecutionResult, ICEAdaptiveBatchRequest, ICEAdaptiveBatchRequestResult, ICERenderBatchingMode, ICERenderBatchingOptions, } from './batching/ICEAdaptiveRenderBatchController.js';
 export { ICERenderBatchPlanner } from './batching/ICERenderBatchPlanner.js';

package/dist/_types/runtime/input/ICEOrbitController.d.ts

@@ -7,6 +7,8 @@ export declare class ICEOrbitController {
     private yaw;
     private pitch;
     private distance;
+    private readonly minDistance;
+    private readonly maxDistance;
     private targetYaw;
     private targetPitch;
     private targetDistance;

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, 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';
+export { ICEBasicMaterial, ICEBoxGeometry, ICEIndexedGeometry, ICEEngineError, ICEAssetLoader, ICETilesetHandle, ICETilesetLoader, ICELabel, ICEMesh, ICENode, ICEOrbitController, ICEPreviewPacketLoader, ICEPerspectiveCamera, ICEScene, ICEScreenLayer, ICETypeRegistry, ICEWorldLayer, ICE3, collectSceneItems, deserializeScene, serializeScene, } 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, ICEPreviewPacketFallbackReason, ICEPreviewPacketLoadResult, ICEPreviewPacketLoaderOptions, ICEPreviewGeometryPacket, } from './_types/runtime/index.js';
 //# sourceMappingURL=index.d.ts.map