@miris-inc/core 0.0.8-e3fcc2a → 0.0.8-e44cce7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/core.d.ts CHANGED
@@ -9,7 +9,9 @@ declare interface AttributeInfo extends EmbindObject {
9
9
  readonly elementCount: number;
10
10
  readonly dataSizeBytes: number;
11
11
  readonly clientSideId: bigint;
12
- readonly minValue: { x: number; y: number; z: number };
12
+ // An embind CompressionType value, compared by identity against MainModule.CompressionType
13
+ readonly compressionType: unknown;
14
+ readonly minValue: { x: number; y: number; z: number; w: number };
13
15
  readonly maxValue: { x: number; y: number; z: number };
14
16
  }
15
17
 
@@ -32,7 +34,13 @@ export declare class AttributeNames {
32
34
  static readonly OCTANT_OFFSETS: string;
33
35
  static readonly SURFEL_OCTANT_OFFSETS: string;
34
36
  static readonly SURFEL_COUNT: string;
37
+ static readonly SURFEL_OWNER_GROUPS: string;
38
+ static readonly OCTANT_CELL: string;
35
39
  static readonly REFLECTANCE_DATA_V1: string;
40
+ static readonly REFLECTANCE_DATA_V2: string;
41
+ static readonly GLASS_MESH_GEOMETRY: string;
42
+ static readonly GLASS_MESH_PANELS: string;
43
+ static readonly TRAINED_MESH: string;
36
44
  static readonly MOD_DEPTH: string;
37
45
  }
38
46
 
@@ -63,6 +71,18 @@ export declare class Camera {
63
71
  constructor({ aspect, fov, near, far, matrix, scene, viewportHeight, }: CameraInit);
64
72
  }
65
73
 
74
+ declare interface Camera_2 {
75
+ dir: vec4;
76
+ U: vec4;
77
+ V: vec4;
78
+ eye: vec4;
79
+ l: number;
80
+ fov: number;
81
+ zNear: number;
82
+ zFar: number;
83
+ delete(): void;
84
+ }
85
+
66
86
  export declare type CameraInit = {
67
87
  aspect: number;
68
88
  fov: number;
@@ -90,7 +110,7 @@ declare class Client {
90
110
  readonly handle: AquaClientHandle;
91
111
  get viewerKey(): string | null;
92
112
  set viewerKey(key: string | null);
93
- constructor({ engine, context }: ClientInit);
113
+ constructor({ engine, context, id, telemetryCollector }: ClientInit);
94
114
  dispose(): void;
95
115
  addStreamById(...args: ClientMethodParameters["addStreamById"]): number;
96
116
  destroyClient(...args: ClientMethodParameters["destroyClient"]): AquaStatus;
@@ -106,7 +126,14 @@ declare class Client {
106
126
  getSceneMetadata(...args: ClientMethodParameters["getSceneMetadata"]): number;
107
127
  getSceneObjectParent(...args: ClientMethodParameters["getSceneObjectParent"]): number;
108
128
  getSceneObjectType(...args: ClientMethodParameters["getSceneObjectType"]): SceneObjectType;
129
+ getStreamStatus(...args: ClientMethodParameters["getStreamStatus"]): StreamStatus;
109
130
  getDrawnOctantMask(...args: ClientMethodParameters["getDrawnOctantMask"]): number;
131
+ getOctantLocalBoundingBoxes(...args: ClientMethodParameters["getOctantLocalBoundingBoxes"]): number[];
132
+ getClusterLodPoolInfo(...args: ClientMethodParameters["getClusterLodPoolInfo"]): ClusterLodPoolInfo | null;
133
+ takeClusterLodPoolWrites(...args: ClientMethodParameters["takeClusterLodPoolWrites"]): ClusterLodPoolWrite[] | null;
134
+ getClusterLodDrawList(...args: ClientMethodParameters["getClusterLodDrawList"]): Uint32Array<ArrayBufferLike> | null;
135
+ hasClusterLodResidualPages(...args: ClientMethodParameters["hasClusterLodResidualPages"]): boolean | null;
136
+ fetchClusterLodPageFile(...args: ClientMethodParameters["fetchClusterLodPageFile"]): boolean;
110
137
  getLocalTransform(...args: ClientMethodParameters["getLocalTransform"]): AquaStatus;
111
138
  getWorldTransform(...args: ClientMethodParameters["getWorldTransform"]): AquaStatus;
112
139
  hasAttribute(...args: ClientMethodParameters["hasAttribute"]): boolean;
@@ -116,6 +143,8 @@ declare class Client {
116
143
  setAssetViewerKey(...args: ClientMethodParameters["setAssetViewerKey"]): AquaStatus;
117
144
  setClientSpatialFormat(...args: ClientMethodParameters["setClientSpatialFormat"]): AquaStatus;
118
145
  setRuntimeSettings(...args: ClientMethodParameters["setRuntimeSettings"]): AquaStatus;
146
+ setStreamFetchMode(...args: ClientMethodParameters["setStreamFetchMode"]): boolean;
147
+ getStreamFetchMode(...args: ClientMethodParameters["getStreamFetchMode"]): number;
119
148
  setMainCameraTransform(...args: ClientMethodParameters["setMainCameraTransform"]): AquaStatus;
120
149
  setMainCameraViewFrustum(...args: ClientMethodParameters["setMainCameraViewFrustum"]): AquaStatus;
121
150
  setSceneObjectTransform(...args: ClientMethodParameters["setSceneObjectTransform"]): AquaStatus;
@@ -133,15 +162,177 @@ declare class Client {
133
162
  updateSceneExecution(...args: ClientMethodParameters["updateSceneExecution"]): AquaStatus;
134
163
  }
135
164
 
165
+ declare type ClientAttributeInfo = {
166
+ elementsPerSplat: number;
167
+ discard: boolean;
168
+ bytes?: true;
169
+ };
170
+
171
+ export declare const clientAttributeList: Record<string, ClientAttributeInfo>;
172
+
136
173
  declare type ClientInit = {
137
174
  engine: Engine;
138
175
  context?: AquaContextHandle;
176
+ id: number;
177
+ /** Must outlive the client. */
178
+ telemetryCollector?: AquaTelemetryCollectorHandle;
139
179
  };
140
180
 
141
181
  declare type ClientMethodParameters<Parameters extends EngineMethodParameters = EngineMethodParameters> = {
142
182
  [Key in keyof Parameters]: Parameters[Key] extends [any, ...infer Rest] ? Rest : [];
143
183
  };
144
184
 
185
+ declare interface ClusterLodDrawState {
186
+ createPool(renderState: RenderState, info: ClusterLodPoolInfo): void;
187
+ releasePool(renderState: RenderState): void;
188
+ applyWrite(
189
+ renderState: RenderState,
190
+ vertexOffset: number,
191
+ verticesPtr: number,
192
+ vertexCount: number,
193
+ triangleOffset: number,
194
+ trianglesPtr: number,
195
+ triangleCount: number,
196
+ clusterOffset: number,
197
+ clustersPtr: number,
198
+ cullSpheresPtr: number,
199
+ clusterCount: number,
200
+ ): void;
201
+ // Culls the cut's slots to the camera, with the mesh in the model root at modelRootIndex, and draws
202
+ // what is left.
203
+ cullAndDraw(
204
+ renderState: RenderState,
205
+ splatSet: SplatSet,
206
+ modelRootIndex: number,
207
+ camera: Camera_2,
208
+ width: number,
209
+ height: number,
210
+ slotsPtr: number,
211
+ slotCount: number,
212
+ ): void;
213
+ delete(): void;
214
+ }
215
+
216
+ export declare interface ClusterLodFrame {
217
+ sceneObjectId: number;
218
+ modelRoot: ModelRoot;
219
+ info: ClusterLodPoolInfo;
220
+ writes: ClusterLodPoolWrite[];
221
+ drawList: Uint32Array;
222
+ writesApplied: () => void;
223
+ fetchPageFile: ClusterLodPageFetch | null;
224
+ }
225
+
226
+ declare type ClusterLodPageFetch = (fileName: string, fileBytes: number, done: ClusterLodPageFileDone) => void;
227
+
228
+ declare type ClusterLodPageFileDone = (bytesPtr: number | null, byteCount: number) => void;
229
+
230
+ declare interface ClusterLodPoolInfo {
231
+ vertexCapacity: number;
232
+ triangleCapacity: number;
233
+ clusterCapacity: number;
234
+ positionMin: number[];
235
+ positionScale: number;
236
+ featureLow: number[];
237
+ featureHigh: number[];
238
+ }
239
+
240
+ declare interface ClusterLodPoolWrite {
241
+ vertexOffset: number;
242
+ vertexCount: number;
243
+ verticesPtr: number;
244
+ triangleOffset: number;
245
+ triangleCount: number;
246
+ trianglesPtr: number;
247
+ clusterOffset: number;
248
+ clusterCount: number;
249
+ clustersPtr: number;
250
+ cullSpheresPtr: number;
251
+ }
252
+
253
+ declare type ClusterLodResidualPageFetch = (
254
+ fileName: string,
255
+ fileBytes: number,
256
+ requestId: number,
257
+ ) => void;
258
+
259
+ declare interface ClusterLodResidualPages {
260
+ complete(requestId: number, bytesPtr: number, byteCount: number): void;
261
+ // Once a frame, after the cluster LOD pool's writes.
262
+ update(renderState: RenderState): void;
263
+ isSettled(renderState: RenderState): boolean;
264
+ pageCount(): number;
265
+ completePageCount(renderState: RenderState): number;
266
+ delete(): void;
267
+ }
268
+
269
+ export declare interface ConfigurationCameraData {
270
+ readonly aspect: number;
271
+ readonly fov: number;
272
+ readonly near: number;
273
+ readonly far: number;
274
+ }
275
+
276
+ export declare type ConfigurationCameraInit = Omit<ConfigurationCameraData, never>;
277
+
278
+ export declare class ConfigurationEntry extends Entry {
279
+ #private;
280
+ static [Symbol.hasInstance](value: unknown): value is MetricsConfigurationEntry;
281
+ constructor(init: ConfigurationEntryInit);
282
+ /* Excluded from this release type: _enqueue */
283
+ }
284
+
285
+ export declare type ConfigurationEntryInit = EntryInit & ({
286
+ target: MirisTarget;
287
+ data: ConfigurationMirisInit;
288
+ } | {
289
+ target: SceneTarget;
290
+ data: ConfigurationSceneInit;
291
+ } | {
292
+ target: ObjectTarget<"camera">;
293
+ data: ConfigurationCameraInit;
294
+ } | {
295
+ target: ObjectTarget<"stream">;
296
+ data: ConfigurationStreamInit;
297
+ });
298
+
299
+ export declare interface ConfigurationMirisData {
300
+ readonly package: string;
301
+ readonly version: string;
302
+ readonly hostname: string;
303
+ readonly campaignId: string;
304
+ readonly creativeId: string;
305
+ readonly placementId: string;
306
+ }
307
+
308
+ export declare type ConfigurationMirisInit = {
309
+ package: MirisPackage;
310
+ version: string;
311
+ hostname: string;
312
+ campaignId?: string;
313
+ creativeId?: string;
314
+ placementId?: string;
315
+ };
316
+
317
+ export declare interface ConfigurationSceneData {
318
+ readonly width: number;
319
+ readonly height: number;
320
+ readonly renderWidth: number;
321
+ readonly renderHeight: number;
322
+ readonly pixelRatio: number;
323
+ readonly viewerKey: string;
324
+ }
325
+
326
+ export declare type ConfigurationSceneInit = Omit<ConfigurationSceneData, never>;
327
+
328
+ export declare interface ConfigurationStreamData {
329
+ readonly assetId: string;
330
+ readonly boundsMin: [number, number, number];
331
+ readonly boundsMax: [number, number, number];
332
+ }
333
+
334
+ export declare type ConfigurationStreamInit = Omit<ConfigurationStreamData, never>;
335
+
145
336
  declare interface EmbindObject {
146
337
  delete(): void;
147
338
  }
@@ -177,11 +368,16 @@ declare class Engine {
177
368
  readonly VariantSetCollection: 7;
178
369
  readonly VariantSet: 8;
179
370
  readonly VariantSetOption: 9;
371
+ readonly ClusterLodMesh: 10;
180
372
  };
181
373
  static Feature: {
182
374
  readonly DrMap: 0;
183
375
  readonly ReflMesh: 1;
184
376
  readonly GlassMesh: 2;
377
+ readonly NeuralMaterialDecoder: 3;
378
+ readonly DirectionalFeatureMap: 4;
379
+ readonly VertexLoss: 5;
380
+ readonly RenderAsPointCloud: 6;
185
381
  };
186
382
  static FeatureState: {
187
383
  readonly NotLoaded: 0;
@@ -189,11 +385,28 @@ declare class Engine {
189
385
  readonly Loaded: 2;
190
386
  readonly Failed: 3;
191
387
  };
388
+ static StreamStatus: {
389
+ readonly Unknown: 0;
390
+ readonly Resolving: 1;
391
+ readonly Loading: 2;
392
+ readonly Ready: 3;
393
+ readonly Failed: 4;
394
+ };
395
+ static StreamFetchMode: {
396
+ readonly Regular: 0;
397
+ readonly Prefetch: 1;
398
+ readonly Parked: 2;
399
+ };
192
400
  readonly ready: Promise<this>;
193
401
  readonly pending: boolean;
194
402
  get module(): MainModule;
195
403
  constructor(moduleOptions?: Record<string, unknown>);
196
404
  get AttributeInfo(): new () => AttributeInfo;
405
+ get CompressionType(): {
406
+ SHARK_ELLIPSOID_COMPRESSED: unknown;
407
+ SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE: unknown;
408
+ SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE_V2: unknown;
409
+ };
197
410
  get Handedness(): {
198
411
  Right: number;
199
412
  Left: number;
@@ -214,6 +427,7 @@ declare class Engine {
214
427
  Y: number;
215
428
  Z: number;
216
429
  };
430
+ get UsePadding(): boolean;
217
431
  activatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
218
432
  addStreamById(...args: [
219
433
  handle: AquaClientHandle,
@@ -224,13 +438,26 @@ declare class Engine {
224
438
  allocateSceneChangesArrays(...args: [sceneChangeIds: SceneChangeIds]): void;
225
439
  createContext(...args: []): AquaContextHandle;
226
440
  destroyContext(...args: [handle: AquaContextHandle]): AquaStatus;
227
- createClient(context?: AquaContextHandle, ...args: []): AquaClientHandle;
441
+ /** telemetryCollector, a collector handle or 0 for none, must outlive the client. */
442
+ createClient(id: number, context?: AquaContextHandle, telemetryCollector?: number): AquaClientHandle;
228
443
  createdObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
229
444
  deletedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
230
445
  dataPtrView(...args: [attributeInfo: AttributeInfo]): Uint32Array;
231
446
  deactivatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
232
447
  remaskedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
233
448
  getDrawnOctantMask(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
449
+ getOctantLocalBoundingBoxes(...args: [handle: AquaClientHandle, sceneObjectId: number]): number[];
450
+ getClusterLodPoolInfo(...args: [handle: AquaClientHandle, sceneObjectId: number]): ClusterLodPoolInfo | null;
451
+ takeClusterLodPoolWrites(...args: [handle: AquaClientHandle, sceneObjectId: number]): ClusterLodPoolWrite[] | null;
452
+ getClusterLodDrawList(...args: [handle: AquaClientHandle, sceneObjectId: number]): Uint32Array | null;
453
+ hasClusterLodResidualPages(...args: [handle: AquaClientHandle, sceneObjectId: number]): boolean | null;
454
+ fetchClusterLodPageFile(...args: [
455
+ handle: AquaClientHandle,
456
+ sceneObjectId: number,
457
+ fileName: string,
458
+ fileBytes: number,
459
+ onComplete: ClusterLodPageFileDone
460
+ ]): boolean;
234
461
  destroyClient(...args: [handle: AquaClientHandle]): AquaStatus;
235
462
  free(...args: [size: number]): number;
236
463
  getAssetsAsync(...args: [handle: AquaClientHandle, tags: StringVector]): AssetInfo[];
@@ -249,6 +476,7 @@ declare class Engine {
249
476
  getSceneChangesCounts(...args: [handle: AquaClientHandle, sceneChangeIds: SceneChangeIds]): void;
250
477
  getSceneMetadata(...args: [handle: AquaClientHandle, metadata: SceneMetadata]): number;
251
478
  getSceneObjectParent(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
479
+ getStreamStatus(...args: [handle: AquaClientHandle, streamObjectId: number]): StreamStatus;
252
480
  getSceneObjectType(...args: [handle: AquaClientHandle, sceneObjectId: number]): SceneObjectType;
253
481
  getLocalTransform(...args: [
254
482
  handle: AquaClientHandle,
@@ -300,8 +528,140 @@ declare class Engine {
300
528
  farPlane: number,
301
529
  viewportHeightPixels: number
302
530
  ]): AquaStatus;
531
+ setStreamFetchMode(...args: [handle: AquaClientHandle, streamObjectId: number, mode: number]): boolean;
532
+ getStreamFetchMode(...args: [handle: AquaClientHandle, streamObjectId: number]): number;
303
533
  setMaxCacheSize(...args: [maxSizeBytes: number]): void;
304
534
  setPreferSharkEncodingProfiles(...args: [preferShark: boolean]): void;
535
+ setPadSplatAttributes(usePadding: boolean): void;
536
+ createTelemetryCollector(...args: [
537
+ sessionId: string,
538
+ sessionStartTimeMs: number,
539
+ isNewSession: boolean,
540
+ mirisId: number
541
+ ]): AquaTelemetryCollectorHandle;
542
+ destroyTelemetryCollector(...args: [handle: AquaTelemetryCollectorHandle]): AquaStatus;
543
+ tickTelemetryCollector(...args: [handle: AquaTelemetryCollectorHandle, monotonicTimeMs: number]): AquaStatus;
544
+ flushTelemetryCollector(...args: [handle: AquaTelemetryCollectorHandle]): AquaStatus;
545
+ /** Session-relative time: milliseconds since the session start, on the collector's clock. */
546
+ getTelemetryCollectorNow(...args: [handle: AquaTelemetryCollectorHandle]): number;
547
+ /** Each client reports to the collector it was created with. */
548
+ tickTelemetrySampler(clients: readonly AquaClientHandle[]): AquaStatus;
549
+ /** Reports each context's open snapshot window now, as tickTelemetrySampler would at its end. */
550
+ flushTelemetrySampler(clients: readonly AquaClientHandle[]): AquaStatus;
551
+ enqueueTelemetryConfigurationMiris(...args: [
552
+ handle: AquaTelemetryCollectorHandle,
553
+ timestampMs: number,
554
+ pkg: number,
555
+ version: string,
556
+ hostname: string,
557
+ campaignId: string,
558
+ creativeId: string,
559
+ placementId: string
560
+ ]): AquaStatus;
561
+ enqueueTelemetryConfigurationScene(...args: [
562
+ handle: AquaTelemetryCollectorHandle,
563
+ timestampMs: number,
564
+ sceneId: number,
565
+ width: number,
566
+ height: number,
567
+ renderWidth: number,
568
+ renderHeight: number,
569
+ pixelRatio: number,
570
+ viewerKey: string
571
+ ]): AquaStatus;
572
+ enqueueTelemetryConfigurationCamera(...args: [
573
+ handle: AquaTelemetryCollectorHandle,
574
+ timestampMs: number,
575
+ sceneId: number,
576
+ cameraId: number,
577
+ aspect: number,
578
+ fov: number,
579
+ nearPlane: number,
580
+ farPlane: number
581
+ ]): AquaStatus;
582
+ enqueueTelemetryConfigurationStream(...args: [
583
+ handle: AquaTelemetryCollectorHandle,
584
+ timestampMs: number,
585
+ sceneId: number,
586
+ streamId: number,
587
+ assetId: string,
588
+ boundsMin: number,
589
+ boundsMax: number
590
+ ]): AquaStatus;
591
+ enqueueTelemetryError(...args: [
592
+ handle: AquaTelemetryCollectorHandle,
593
+ timestampMs: number,
594
+ name: number,
595
+ message: string
596
+ ]): AquaStatus;
597
+ enqueueTelemetryLifecycle(...args: [
598
+ handle: AquaTelemetryCollectorHandle,
599
+ timestampMs: number,
600
+ durationMs: number,
601
+ targetType: number,
602
+ sceneId: number,
603
+ objectId: number,
604
+ octantId: number,
605
+ name: number
606
+ ]): AquaStatus;
607
+ enqueueTelemetryInteractionPointer(...args: [
608
+ handle: AquaTelemetryCollectorHandle,
609
+ timestampMs: number,
610
+ targetType: number,
611
+ sceneId: number,
612
+ objectId: number,
613
+ name: number,
614
+ x: number,
615
+ y: number,
616
+ button: number
617
+ ]): AquaStatus;
618
+ enqueueTelemetryInteractionWheel(...args: [
619
+ handle: AquaTelemetryCollectorHandle,
620
+ timestampMs: number,
621
+ targetType: number,
622
+ sceneId: number,
623
+ objectId: number,
624
+ x: number,
625
+ y: number,
626
+ button: number,
627
+ deltaX: number,
628
+ deltaY: number,
629
+ deltaZ: number
630
+ ]): AquaStatus;
631
+ enqueueTelemetrySnapshot(...args: [
632
+ handle: AquaTelemetryCollectorHandle,
633
+ timestampMs: number,
634
+ durationMs: number,
635
+ averageMainThreadTime: number,
636
+ averageActiveStreamCount: number,
637
+ averageFps: number,
638
+ averageVisibleNodes: number,
639
+ averageVisibleSplats: number,
640
+ averageCacheUsedBytes: number,
641
+ averageHeapUsedBytes: number,
642
+ averageHeapTotalBytes: number
643
+ ]): AquaStatus;
644
+ enqueueTelemetryTiming(...args: [
645
+ handle: AquaTelemetryCollectorHandle,
646
+ timestampMs: number,
647
+ durationMs: number,
648
+ targetType: number,
649
+ sceneId: number,
650
+ objectId: number,
651
+ name: number
652
+ ]): AquaStatus;
653
+ enqueueTelemetryTransformation(...args: [
654
+ handle: AquaTelemetryCollectorHandle,
655
+ timestampMs: number,
656
+ targetType: number,
657
+ sceneId: number,
658
+ objectId: number,
659
+ position: number,
660
+ quaternion: number,
661
+ scale: number
662
+ ]): AquaStatus;
663
+ get MetricsObserver(): MetricsObserverConstructor;
664
+ getTelemetryHistory(collector: AquaTelemetryCollectorHandle): MetricsEntry[];
305
665
  setSceneObjectTransform(...args: [
306
666
  handle: AquaClientHandle,
307
667
  sceneObjectId: number,
@@ -330,9 +690,16 @@ declare class Engine {
330
690
  * displayed frame per context, before the per-client updateSceneExecution() calls.
331
691
  * `previousFrameTimeMs` is how long the previous frame took; pass 0 when there is no plausible
332
692
  * measurement (first frame, or a resume from a stall) and the frame advances without recording
333
- * one.
693
+ * `primsResident` is what the renderer held at the end of the previous frame, fading
694
+ * prims included, and `primCapacity` what it can hold; activations that would not fit are
695
+ * deferred, where primCapacity 0 means deferral is disabled.
334
696
  */
335
- beginFrame(...args: [contextHandle: AquaContextHandle, previousFrameTimeMs: number]): AquaStatus;
697
+ beginFrame(...args: [
698
+ contextHandle: AquaContextHandle,
699
+ previousFrameTimeMs: number,
700
+ primsResident: number,
701
+ primCapacity: number
702
+ ]): AquaStatus;
336
703
  createDeserializeWorker(_url: string, _workerUrl: string, poolSize: number): boolean;
337
704
  cancelRequest(requestIdLow: number, requestIdHigh: number): boolean;
338
705
  submitToWorker(requestIdLow: number, requestIdHigh: number, descriptorBuffer: ArrayBuffer, contextPtr: number): boolean;
@@ -346,6 +713,175 @@ declare type EngineMethodParameters<E extends Engine = Engine> = {
346
713
  [Key in keyof E]: E[Key] extends (...args: any[]) => any ? Parameters<E[Key]> : never;
347
714
  };
348
715
 
716
+ /* Excluded from this release type: EnqueueContext */
717
+
718
+ export declare abstract class Entry {
719
+ static [Symbol.hasInstance](value: unknown): value is MetricsEntry;
720
+ /* Excluded from this release type: _enqueue */
721
+ }
722
+
723
+ export declare type EntryInit = {
724
+ /**
725
+ * When the event happened, as session time; defaults to now. Convert other clocks with
726
+ * metrics.toSessionTime(): a raw performance.now() time or event.timeStamp is not session time.
727
+ */
728
+ startTime?: SessionTime;
729
+ };
730
+
731
+ export declare type EntryType = MetricsEntryType;
732
+
733
+ /** The entry types a MetricsObserver can receive and Metrics keeps. */
734
+ export declare type EntryTypeMap = {
735
+ configuration: MetricsConfigurationEntry;
736
+ interaction: MetricsInteractionEntry;
737
+ lifecycle: MetricsLifecycleEntry;
738
+ timing: MetricsTimingEntry;
739
+ transformation: MetricsTransformationEntry;
740
+ };
741
+
742
+ declare const ERROR_NAME_ORDINAL: {
743
+ readonly error: 0;
744
+ readonly fatal: 1;
745
+ readonly streaming: 2;
746
+ readonly network: 3;
747
+ };
748
+
749
+ export declare class ErrorEntry extends Entry {
750
+ #private;
751
+ static [Symbol.hasInstance](value: unknown): value is MetricsErrorEntry;
752
+ constructor(init: ErrorEntryInit);
753
+ /* Excluded from this release type: _enqueue */
754
+ }
755
+
756
+ export declare type ErrorEntryInit = EntryInit & {
757
+ name: ErrorEntryName;
758
+ message?: string;
759
+ };
760
+
761
+ export declare type ErrorEntryName = keyof typeof ERROR_NAME_ORDINAL;
762
+
763
+ declare interface GlassMeshRegistry {
764
+ // Decodes one octree node's glass payload and registers it, replacing any previous entry for
765
+ // that object. False for a malformed or empty payload, leaving the registry unchanged.
766
+ //
767
+ // The two slot arguments are different numbers here, unlike on the native path, and swapping
768
+ // them renders glass that does not follow its asset: modelRootSlot scopes the panel dedupe to
769
+ // one asset instance, while chunkModelRootIndex is stamped into every vertex and read back as
770
+ // chunkModelRoots[pos.w], so that one takes the chunk's fade slot.
771
+ //
772
+ // geometryPtr/panelPtr address THIS module's heap - _malloc here and copy the bytes in, since
773
+ // the attributes live in the engine module's. The AABB is the geometry attribute's own range.
774
+ registerObject(
775
+ objectId: number,
776
+ lodIndex: number,
777
+ modelRootSlot: number,
778
+ chunkModelRootIndex: number,
779
+ geometryPtr: number,
780
+ geometryByteCount: number,
781
+ panelPtr: number,
782
+ panelByteCount: number,
783
+ aabbMinX: number,
784
+ aabbMinY: number,
785
+ aabbMinZ: number,
786
+ aabbMaxX: number,
787
+ aabbMaxY: number,
788
+ aabbMaxZ: number,
789
+ ): boolean;
790
+ // Returns true if the object had glass, which is what says the buffers need rebuilding.
791
+ removeObject(objectId: number): boolean;
792
+ clear(): void;
793
+ isDirty(): boolean;
794
+ // Rebuilds the flattened buffers, keeping each panel from its deepest resident LOD. Stays dirty
795
+ // so uploadIfDirty still fires. Walks every registered object, so not per frame.
796
+ flattenIfDirty(): void;
797
+ uploadIfDirty(renderState: RenderState): void;
798
+ vertexCount(): number;
799
+ panelCount(): number;
800
+ delete(): void;
801
+ }
802
+
803
+ export declare const HaveData = 2;
804
+
805
+ export declare const HaveMetadata = 1;
806
+
807
+ export declare const HaveNothing = 0;
808
+
809
+ declare const INTERACTION_NAME_ORDINAL: {
810
+ readonly click: 0;
811
+ readonly "context-menu": 1;
812
+ readonly "double-click": 2;
813
+ readonly "pointer-down": 3;
814
+ readonly "pointer-enter": 4;
815
+ readonly "pointer-leave": 5;
816
+ readonly "pointer-move": 6;
817
+ readonly "pointer-up": 7;
818
+ readonly wheel: 8;
819
+ };
820
+
821
+ export declare interface InteractionData {
822
+ readonly x: number;
823
+ readonly y: number;
824
+ readonly button: number;
825
+ readonly deltaX?: number;
826
+ readonly deltaY?: number;
827
+ readonly deltaZ?: number;
828
+ }
829
+
830
+ export declare class InteractionEntry extends Entry {
831
+ #private;
832
+ static [Symbol.hasInstance](value: unknown): value is MetricsInteractionEntry;
833
+ constructor(init: InteractionEntryInit);
834
+ /* Excluded from this release type: _enqueue */
835
+ }
836
+
837
+ export declare type InteractionEntryInit = EntryInit & {
838
+ target: SceneTarget | ObjectTarget<"stream">;
839
+ name: InteractionEntryName;
840
+ data: {
841
+ x: number;
842
+ y: number;
843
+ button?: number;
844
+ deltaX?: number;
845
+ deltaY?: number;
846
+ deltaZ?: number;
847
+ };
848
+ };
849
+
850
+ export declare type InteractionEntryName = keyof typeof INTERACTION_NAME_ORDINAL;
851
+
852
+ declare const LIFECYCLE_NAME_ORDINAL: {
853
+ readonly create: 0;
854
+ readonly enable: 1;
855
+ readonly load: 2;
856
+ readonly disable: 3;
857
+ readonly remove: 4;
858
+ readonly delete: 5;
859
+ readonly add: 6;
860
+ readonly suspend: 7;
861
+ readonly abort: 8;
862
+ readonly error: 9;
863
+ readonly decode: 10;
864
+ readonly cache: 11;
865
+ readonly show: 12;
866
+ readonly hide: 13;
867
+ readonly evict: 14;
868
+ };
869
+
870
+ export declare class LifecycleEntry extends Entry {
871
+ #private;
872
+ static [Symbol.hasInstance](value: unknown): value is MetricsLifecycleEntry;
873
+ constructor(init: LifecycleEntryInit);
874
+ /* Excluded from this release type: _enqueue */
875
+ }
876
+
877
+ export declare type LifecycleEntryInit = EntryInit & {
878
+ target: TelemetryTarget;
879
+ name: LifecycleEntryName;
880
+ duration?: DOMHighResTimeStamp;
881
+ };
882
+
883
+ export declare type LifecycleEntryName = keyof typeof LIFECYCLE_NAME_ORDINAL;
884
+
349
885
  export declare class Lod {
350
886
  #private;
351
887
  readonly id: LodInit["id"];
@@ -376,14 +912,19 @@ export declare class Lod {
376
912
  get transform(): Float32Array<ArrayBuffer> | null;
377
913
  get _drawnOctantMask(): number;
378
914
  set _drawnOctantMask(mask: number);
915
+ get _octantLocalBounds(): Float32Array<ArrayBuffer> | null;
916
+ set _octantLocalBounds(bounds: Float32Array<ArrayBuffer> | null);
379
917
  get _octantOffsets(): Uint32Array<ArrayBuffer> | null;
380
918
  get _hasOctantOffsets(): boolean;
381
919
  get _surfelOctantOffsets(): Uint32Array<ArrayBuffer> | null;
382
920
  get _surfelCount(): number;
921
+ get _surfelOwnerGroups(): Uint32Array<ArrayBuffer> | null;
922
+ get _octantCell(): Uint32Array<ArrayBuffer> | null;
383
923
  _readOctantOffsets(engine: Engine): void;
384
924
  hasAttribute(attributeName: string): boolean;
385
925
  getDataFromAttribute(engine: Engine, attributeName: string, attributeInfo: AttributeInfo): CachedAttribute | null;
386
926
  _getRawByteAttribute(engine: Engine, attributeName: string): Uint8Array<ArrayBuffer> | null;
927
+ _getRawByteAttributeWithBounds(engine: Engine, attributeName: string): RawByteAttributeWithBounds | null;
387
928
  dispose(): void;
388
929
  constructor({ id, modelRoot, lodStore, client }: LodInit);
389
930
  }
@@ -406,8 +947,13 @@ export declare class LodStore {
406
947
  deleteId(id: number): void;
407
948
  }
408
949
 
409
- declare interface MainModule {
950
+ declare interface MainModule extends SharkModule {
410
951
  AttributeInfo: new () => AttributeInfo;
952
+ CompressionType: {
953
+ SHARK_ELLIPSOID_COMPRESSED: unknown;
954
+ SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE: unknown;
955
+ SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE_V2: unknown;
956
+ };
411
957
  Handedness: { Right: number; Left: number };
412
958
  HEAPF32: Float32Array<ArrayBuffer>;
413
959
  HEAPU8: Uint8Array<ArrayBuffer>;
@@ -436,25 +982,213 @@ declare interface MainModule {
436
982
  remaskedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
437
983
  deletedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
438
984
  GetDrawnOctantMask(handle: number, sceneObjectId: number): number;
985
+ GetOctantLocalBoundingBoxes(handle: number, sceneObjectId: number): number[];
986
+ GetClusterLodPoolInfo(handle: number, sceneObjectId: number): ClusterLodPoolInfo | null;
987
+ TakeClusterLodPoolWrites(handle: number, sceneObjectId: number): ClusterLodPoolWrite[] | null;
988
+ GetClusterLodDrawList(handle: number, sceneObjectId: number): Uint32Array | null;
989
+ HasClusterLodResidualPages(handle: number, sceneObjectId: number): boolean | null;
990
+ FetchClusterLodPageFile(
991
+ handle: number,
992
+ sceneObjectId: number,
993
+ fileName: string,
994
+ fileBytes: number,
995
+ onComplete: ClusterLodPageFileDone,
996
+ ): boolean;
439
997
  GetAssetsAsync(handle: number, tags: StringVector): unknown[];
440
998
  GetSceneChanges(handle: number, sceneChangeIds: SceneChangeIds): void;
441
999
  GetSceneChangesCounts(handle: number, sceneChangeIds: SceneChangeIds): void;
442
1000
  GetSceneMetadata(handle: number, metadata: SceneMetadata): { value: number };
443
1001
  GetName(handle: number, sceneObjectId: number): string;
444
1002
  HasFeature(handle: number, sceneObjectId: number, feature: number): boolean;
445
- GetFeatureVersion(handle: number, sceneObjectId: number, feature: number): number;
446
- GetFeatureState(handle: number, sceneObjectId: number, feature: number): number;
1003
+ GetFeatureVersion(
1004
+ handle: number,
1005
+ sceneObjectId: number,
1006
+ feature: number,
1007
+ ): number;
1008
+ GetFeatureState(
1009
+ handle: number,
1010
+ sceneObjectId: number,
1011
+ feature: number,
1012
+ ): number;
447
1013
  GetAssetFormatVersion(handle: number, sceneObjectId: number): number;
448
- GetDrMapLadderRoughnessLevels(handle: number, sceneObjectId: number): number[];
449
- SetClientSpatialFormat(handle: number, spatialFormat: SpatialFormat): { value: number };
450
- SetRuntimeSettings(handle: number, settings: RuntimeSettings): { value: number };
1014
+ GetDrMapLadderRoughnessLevels(
1015
+ handle: number,
1016
+ sceneObjectId: number,
1017
+ ): number[];
1018
+ SetClientSpatialFormat(
1019
+ handle: number,
1020
+ spatialFormat: SpatialFormat,
1021
+ ): { value: number };
1022
+ SetRuntimeSettings(
1023
+ handle: number,
1024
+ settings: RuntimeSettings,
1025
+ ): { value: number };
1026
+ SetStreamFetchMode(
1027
+ handle: number,
1028
+ streamObjectId: number,
1029
+ mode: number,
1030
+ ): boolean;
1031
+ GetStreamFetchMode(handle: number, streamObjectId: number): number;
451
1032
  TakeEvictedClientSideAttributeIds(handle: number): EmbindVector<bigint>;
452
1033
  GetActiveClientSideIdsCheckSum(): number;
453
1034
  TakeRenderRequired(handle: number): boolean;
454
- BeginFrame(contextHandle: number, previousFrameTimeMs: number): number;
1035
+ BeginFrame(
1036
+ contextHandle: number,
1037
+ previousFrameTimeMs: number,
1038
+ primsResident: number,
1039
+ primCapacity: number,
1040
+ ): number;
455
1041
  modifiedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
456
1042
  setMaxCacheSize(maxSizeBytes: number): void;
457
1043
  SetPreferSharkEncodingProfiles(prefer: boolean): void;
1044
+ SetLossHeatmapEnabled(handle: number, enabled: boolean): void;
1045
+
1046
+ MetricsObserver: MetricsObserverConstructor;
1047
+ getTelemetryHistory(collectorHandle: number): MetricsEntry[];
1048
+ }
1049
+
1050
+ export declare class Metrics {
1051
+ #private;
1052
+ constructor(engine: Engine, collector: AquaTelemetryCollectorHandle, sessionStartTimeMs: number);
1053
+ get timeOrigin(): DOMHighResTimeStamp;
1054
+ /** Session time now: milliseconds since the session start, on the collector's clock. */
1055
+ now(): SessionTime;
1056
+ /** Converts a performance.now() time, or an Event's timeStamp, to session time. */
1057
+ toSessionTime(time: DOMHighResTimeStamp | Event): SessionTime;
1058
+ queue<E extends Entry>(entry: E): E;
1059
+ /** Every public entry Aqua still remembers, oldest first; none once detached. */
1060
+ getEntries(): MetricsEntry[];
1061
+ getEntriesByName(name: string, type?: string): MetricsEntry[];
1062
+ getEntriesByType<K extends keyof EntryTypeMap>(type: K): EntryTypeMap[K][];
1063
+ getEntriesByType(type: string): MetricsEntry[];
1064
+ /* Excluded from this release type: _detach */
1065
+ }
1066
+
1067
+ export declare interface MetricsConfigurationEntry extends MetricsEntry {
1068
+ readonly type: "configuration";
1069
+ readonly data:
1070
+ | ConfigurationMirisData
1071
+ | ConfigurationSceneData
1072
+ | ConfigurationCameraData
1073
+ | ConfigurationStreamData;
1074
+ }
1075
+
1076
+ export declare interface MetricsEntry {
1077
+ readonly entryId: number;
1078
+ readonly name: string;
1079
+ readonly type: MetricsEntryType;
1080
+ readonly platform: string;
1081
+ /** ms since the session start. */
1082
+ readonly startTime: number;
1083
+ readonly duration: number;
1084
+ /** "<miris>-<scene>[-<camera|stream>[-<octant>]]"; empty for the session target. */
1085
+ readonly targetId: string;
1086
+ readonly targetType: MetricsTargetType;
1087
+ readonly sessionId: string;
1088
+ }
1089
+
1090
+ declare type MetricsEntryType =
1091
+ | "configuration"
1092
+ | "error"
1093
+ | "interaction"
1094
+ | "lifecycle"
1095
+ | "session"
1096
+ | "snapshot"
1097
+ | "timing"
1098
+ | "transformation";
1099
+
1100
+ export declare interface MetricsErrorEntry extends MetricsEntry {
1101
+ readonly type: "error";
1102
+ readonly message: string;
1103
+ }
1104
+
1105
+ export declare interface MetricsInteractionEntry extends MetricsEntry {
1106
+ readonly type: "interaction";
1107
+ readonly data: InteractionData;
1108
+ }
1109
+
1110
+ export declare interface MetricsLifecycleEntry extends MetricsEntry {
1111
+ readonly type: "lifecycle";
1112
+ }
1113
+
1114
+ export declare class MetricsObserver {
1115
+ #private;
1116
+ static get supportedEntryTypes(): EntryType[];
1117
+ constructor(callback: MetricsObserverCallback, options?: MetricsObserverOptions);
1118
+ observe(options?: MetricsObserverInit): void;
1119
+ disconnect(): void;
1120
+ takeRecords(): MetricsEntry[];
1121
+ }
1122
+
1123
+ declare interface MetricsObserver_2 extends EmbindObject {
1124
+ observe(options?: MetricsObserverInit_2): void;
1125
+ disconnect(): void;
1126
+ takeRecords(): MetricsEntry[];
1127
+ }
1128
+
1129
+ export declare type MetricsObserverCallback = (entries: MetricsObserverEntryList, observer: MetricsObserver) => void;
1130
+
1131
+ declare type MetricsObserverCallback_2 = (
1132
+ entries: MetricsEntry[],
1133
+ observer: undefined,
1134
+ ) => void;
1135
+
1136
+ declare interface MetricsObserverConstructor {
1137
+ new (
1138
+ collectorHandle: number,
1139
+ callback: MetricsObserverCallback_2,
1140
+ options: MetricsObserverConstructorOptions,
1141
+ ): MetricsObserver_2;
1142
+ /** The public entry types, the only ones a MetricsObserver can receive. */
1143
+ supportedEntryTypes(): MetricsEntryType[];
1144
+ }
1145
+
1146
+ declare interface MetricsObserverConstructorOptions {
1147
+ flushInterval?: number;
1148
+ }
1149
+
1150
+ export declare class MetricsObserverEntryList {
1151
+ #private;
1152
+ constructor(entries: MetricsEntry[]);
1153
+ getEntries(): MetricsEntry[];
1154
+ getEntriesByName(name: string, type?: string): MetricsEntry[];
1155
+ getEntriesByType(type: string): MetricsEntry[];
1156
+ }
1157
+
1158
+ export declare type MetricsObserverInit = {
1159
+ buffered?: boolean;
1160
+ entryTypes?: string[];
1161
+ type?: string;
1162
+ };
1163
+
1164
+ declare interface MetricsObserverInit_2 {
1165
+ entryTypes?: string[];
1166
+ type?: string;
1167
+ buffered?: boolean;
1168
+ }
1169
+
1170
+ export declare type MetricsObserverOptions = {
1171
+ /** Seconds between flushes to the callback; 0 flushes only on overflow. Default 30. */
1172
+ flushInterval?: number;
1173
+ };
1174
+
1175
+ export declare interface MetricsSnapshotEntry extends MetricsEntry {
1176
+ readonly type: "snapshot";
1177
+ readonly data: SnapshotData;
1178
+ }
1179
+
1180
+ declare type MetricsTargetType =
1181
+ "miris" | "scene" | "camera" | "stream" | "octant" | "session";
1182
+
1183
+ export declare interface MetricsTimingEntry extends MetricsEntry {
1184
+ readonly type: "timing";
1185
+ }
1186
+
1187
+ export declare interface MetricsTransformationEntry extends MetricsEntry {
1188
+ readonly type: "transformation";
1189
+ readonly position: [number, number, number];
1190
+ readonly quaternion: [number, number, number, number];
1191
+ readonly scale: [number, number, number];
458
1192
  }
459
1193
 
460
1194
  /**
@@ -469,14 +1203,23 @@ export declare class Miris {
469
1203
  #private;
470
1204
  static tryUseShark: boolean;
471
1205
  static _instance: Miris;
1206
+ /** The package this Miris reports in configuration/miris. */
1207
+ static readonly package: MirisPackage;
472
1208
  static instance<T extends typeof Miris>(this: T): Promise<InstanceType<T>>;
473
1209
  readonly engine: Engine;
474
1210
  readonly ready: Promise<this>;
475
1211
  readonly pending: boolean;
1212
+ /** Unique within the telemetry session; defined once `ready` resolves, if it joined one. */
1213
+ readonly id: number;
476
1214
  get sharedContext(): number | undefined;
1215
+ get telemetryCollector(): number | undefined;
1216
+ get metrics(): Metrics;
477
1217
  get viewerKey(): string | null | undefined;
478
1218
  set viewerKey(viewerKey: string | null | undefined);
479
1219
  get scenes(): Set<Scene>;
1220
+ /* Excluded from this release type: _trackLiveScene */
1221
+ /* Excluded from this release type: _untrackLiveScene */
1222
+ /* Excluded from this release type: _createNewClientId */
480
1223
  get useSphericalHarmonics(): boolean;
481
1224
  set useSphericalHarmonics(value: boolean);
482
1225
  constructor();
@@ -486,6 +1229,7 @@ export declare class Miris {
486
1229
  protected _xrSession: XRSession | null;
487
1230
  protected _requestAnimationFrame: RequestAnimationFrameFn | null;
488
1231
  signalResumeFromIdle(): void;
1232
+ /* Excluded from this release type: _enableClusterLod */
489
1233
  get _splatCountBudget(): number;
490
1234
  /**
491
1235
  * Why 43? Because the AVP throttles down to 45Hz :(
@@ -493,15 +1237,21 @@ export declare class Miris {
493
1237
  static readonly _XR_TARGET_FRAME_RATE = 43;
494
1238
  /* Excluded from this release type: _XR_SPLAT_COUNT_BUDGET */
495
1239
  /* Excluded from this release type: _SHARK_SPLAT_CAPACITY_MOBILE */
496
- static readonly _SHARK_SPLAT_CAPACITY_DESKTOP = 3000000;
1240
+ static readonly _SHARK_SPLAT_CAPACITY_DESKTOP: number;
497
1241
  /* Excluded from this release type: _SHARK_SPLAT_BUDGET_CAP_MOBILE */
498
- static readonly _SHARK_SPLAT_BUDGET_CAP_DESKTOP = 2500000;
1242
+ static readonly _SHARK_SPLAT_BUDGET_CAP_DESKTOP = 2400000;
1243
+ /* Excluded from this release type: _CLUSTER_LOD_POOL_BYTES_MOBILE */
499
1244
  /* Excluded from this release type: _isMobileDevice */
500
1245
  /* Excluded from this release type: _sharkSplatCapacity */
1246
+ /* Excluded from this release type: _minimumSplatCount */
1247
+ /* Excluded from this release type: _splatCountStorageKey */
1248
+ /* Excluded from this release type: _reloadWithLowerSplatCapacity */
1249
+ /* Excluded from this release type: _limitSharkSplatCapacity */
501
1250
  /* Excluded from this release type: _sharkSplatBudgetCap */
502
1251
  /* Excluded from this release type: _setTargetFrameRate */
503
1252
  /* Excluded from this release type: _setXRModeActive */
504
1253
  /* Excluded from this release type: _setSplatCountBudgetOverride */
1254
+ /* Excluded from this release type: _reportRendererPrims */
505
1255
  /* Excluded from this release type: _update */
506
1256
  getLocalTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
507
1257
  getWorldTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
@@ -513,10 +1263,16 @@ export declare class Miris {
513
1263
  delete(scene: Scene): void;
514
1264
  }
515
1265
 
1266
+ export declare type MirisPackage = keyof typeof PACKAGE_ORDINAL;
1267
+
1268
+ /** What an entry is about: `id`s are Scene, Camera and Stream ids. */
1269
+ export declare type MirisTarget = {
1270
+ readonly type: "miris";
1271
+ };
1272
+
516
1273
  export declare class ModelRoot {
517
1274
  #private;
518
1275
  static forKey(key: unknown): ModelRoot | undefined;
519
- static forId(id: number): ModelRoot | undefined;
520
1276
  readonly id: ModelRootInit["id"];
521
1277
  get key(): unknown;
522
1278
  set key(key: unknown);
@@ -534,6 +1290,119 @@ export declare type ModelRootInit = {
534
1290
  stream: Stream;
535
1291
  };
536
1292
 
1293
+ export declare type ObjectTarget<Type extends "camera" | "stream" = "camera" | "stream"> = {
1294
+ readonly type: Type;
1295
+ readonly id: number;
1296
+ readonly scene: {
1297
+ readonly id: number;
1298
+ };
1299
+ };
1300
+
1301
+ declare const PACKAGE_ORDINAL: {
1302
+ readonly "@miris-inc/core": 0;
1303
+ readonly "@miris-inc/components": 1;
1304
+ readonly "@miris-inc/three": 2;
1305
+ };
1306
+
1307
+ /**
1308
+ * The byte-exact counterpart of getRawUint32Attribute above: same no-padding, no-takeAttribute
1309
+ * contract, returning bytes rather than words.
1310
+ *
1311
+ * Use this rather than that one wherever the stride is not a whole number of words: the
1312
+ * reflectance records' 18- and 26-byte strides are not, and an odd record count would lose that
1313
+ * record's last field to dataPtrView's truncation.
1314
+ */
1315
+ export declare type RawByteAttributeWithBounds = {
1316
+ bytes: Uint8Array<ArrayBuffer>;
1317
+ minValue: {
1318
+ x: number;
1319
+ y: number;
1320
+ z: number;
1321
+ };
1322
+ maxValue: {
1323
+ x: number;
1324
+ y: number;
1325
+ z: number;
1326
+ };
1327
+ };
1328
+
1329
+ declare type ReadyState_2 = typeof HaveNothing | typeof HaveMetadata | typeof HaveData;
1330
+ export { ReadyState_2 as ReadyState }
1331
+
1332
+ declare interface RendererWGPU {
1333
+ getProgramCount(): number;
1334
+ getTextureCount(): number;
1335
+ getEstimatedTextureSize(): number;
1336
+ getTotalBufferSize(): number;
1337
+ getGpuBufferSize(): number;
1338
+ getUploadBufferSize(): number;
1339
+ info: SharkInfo;
1340
+ delete(): void;
1341
+ }
1342
+
1343
+ declare interface RenderState {
1344
+ delete(): void;
1345
+ initRenderState(
1346
+ renderer: RendererWGPU,
1347
+ width: number,
1348
+ height: number,
1349
+ vertices: number,
1350
+ splats: number,
1351
+ cubes: number,
1352
+ sortThreads: number,
1353
+ sortGroupSize: number,
1354
+ sortKeySize: number,
1355
+ ): void;
1356
+ initGraphicsState(
1357
+ width: number,
1358
+ height: number,
1359
+ renderTextureFormat: TextureFormatValue,
1360
+ depthTextureFormat: TextureFormatValue,
1361
+ ): void;
1362
+ updateRenderDetails(
1363
+ width: number,
1364
+ height: number,
1365
+ splatTriangles: number,
1366
+ ): void;
1367
+ // Decodes Radiance .hdr bytes into roughness-ladder level `level` (0 is the sharp mirror).
1368
+ // hdrPtr must address THIS module's heap - _malloc here and copy the bytes in.
1369
+ // Returns false for bytes that are not a usable Radiance image, or a level out of range.
1370
+ uploadEnvironmentLadderLevelFromHdr(
1371
+ level: number,
1372
+ sigmaDeg: number,
1373
+ hdrPtr: number,
1374
+ hdrSizeBytes: number,
1375
+ ): boolean;
1376
+ // Republish the ladder's shape. Call after any level lands, or it is sampled at whatever shape
1377
+ // the last uploadSplatSetData declared. Pass SplatSet.hasReflectionParams().
1378
+ uploadReflectionLadderParams(reflectionsEnabled: boolean): void;
1379
+ // Debug controls. Drop the reflection term, or replace the surfel colour with one of the layers
1380
+ // it is shaded from, numbered as RenderViewModes.h's AOV_* defines. setRenderView below sets
1381
+ // the AOV together with the rest of a named view.
1382
+ setReflectionsEnabled(enabled: boolean): void;
1383
+ // Render textured gaussians on pixels no surfel covers, resolved as fvdb's open gate does.
1384
+ // Off by default: those pixels show the clear colour.
1385
+ setSurfelLessTextureSplatsEnabled(enabled: boolean): void;
1386
+ setDebugAovMode(mode: number): void;
1387
+ // chunkModelRootIndex is a fade slot of one of the trained mesh's chunks.
1388
+ setTrainedMeshMode(active: boolean, chunkModelRootIndex: number): void;
1389
+ // A Mesh View, indexed as trainedMeshViewName orders them, and the gain on its signed channel views.
1390
+ setTrainedMeshView(view: number, scale: number): void;
1391
+ // Enabled, draws only the trained mesh stream piece with this id.
1392
+ setTrainedMeshFilter(enabled: boolean, pieceId: number): void;
1393
+ isTrainedMeshLoaded(): boolean;
1394
+ hasClusterLodPool(): boolean;
1395
+ setResidualEnabled(enabled: boolean): void;
1396
+ // The largest buffer the device binds as storage, in bytes: AquaApi's clusterLodMaxBufferBytes.
1397
+ largestStorageBufferBytes(): number;
1398
+ // GPU pass timing. Turning it on makes every pass write timestamps; a no-op on a device without
1399
+ // timestamp-query. resolveTimeStamps goes after a frame's render; passTimingsMs starts a readback
1400
+ // of them unless one is in flight and maps pass name to milliseconds from the last that landed.
1401
+ setPassTimingEnabled(enabled: boolean): void;
1402
+ resolveTimeStamps(): void;
1403
+ passTimingsMs(): Record<string, number>;
1404
+ }
1405
+
537
1406
  declare type RequestAnimationFrameFn = ((callback: FrameRequestCallback) => number) | ((callback: XRFrameRequestCallback) => void);
538
1407
 
539
1408
  declare interface RuntimeSettings extends EmbindObject {
@@ -543,6 +1412,10 @@ declare interface RuntimeSettings extends EmbindObject {
543
1412
  xrModeActive: boolean;
544
1413
  splatCountBudget: number;
545
1414
  splatCountBudgetCap: number;
1415
+ // 0 for the platform's default.
1416
+ clusterLodPoolBudgetBytes: number;
1417
+ // The renderer's largest storage buffer; 0 for no limit.
1418
+ clusterLodMaxBufferBytes: number;
546
1419
  }
547
1420
 
548
1421
  export declare class Scene extends EventTarget {
@@ -559,6 +1432,9 @@ export declare class Scene extends EventTarget {
559
1432
  set viewerKey(viewerKey: string | null);
560
1433
  get streams(): Set<Stream>;
561
1434
  get lods(): LodStore;
1435
+ /* Excluded from this release type: _addClusterLodMesh */
1436
+ /* Excluded from this release type: _deleteClusterLodMesh */
1437
+ /* Excluded from this release type: _updateClusterLodMeshes */
562
1438
  readonly miris: Miris;
563
1439
  readonly engine: Engine;
564
1440
  readonly client: Client;
@@ -586,13 +1462,19 @@ export declare class Scene extends EventTarget {
586
1462
  add(stream: Stream): void;
587
1463
  getStreamForId(streamObjectId: number): Stream | undefined;
588
1464
  getStreamForDescendentId(descendentObjectId: number): Stream | null;
1465
+ /** This scene's model root with the id, which another scene's client may also use. */
1466
+ getModelRootForId(modelRootId: number): ModelRoot | null;
589
1467
  getModelRootForDescendentId(descendentObjectId: number): ModelRoot | null;
590
1468
  _recordAssetFormat(modelRoot: ModelRoot, formatVersion: number): void;
591
1469
  /* Excluded from this release type: _getFeatureMesh */
1470
+ /* Excluded from this release type: _takeAttributeBuffer */
592
1471
  /* Excluded from this release type: _getDrMap */
593
1472
  /* Excluded from this release type: _onDrMapLadder */
594
1473
  /* Excluded from this release type: _onFeatureData */
1474
+ /* Excluded from this release type: _applyStreamFetchModes */
1475
+ /* Excluded from this release type: _updateStreamStatuses */
595
1476
  /* Excluded from this release type: _onSceneLoaded */
1477
+ /* Excluded from this release type: _releaseStreamId */
596
1478
  delete(stream: Stream): void;
597
1479
  close(): void;
598
1480
  }
@@ -615,12 +1497,165 @@ declare interface SceneMetadata extends EmbindObject {
615
1497
  readonly inputColorSpace: string;
616
1498
  }
617
1499
 
618
- declare type SparkAttributeInfo = {
619
- elementsPerSplat: number;
620
- discard: boolean;
1500
+ export declare type SceneTarget = {
1501
+ readonly type: "scene";
1502
+ readonly id: number;
621
1503
  };
622
1504
 
623
- export declare const sparkAttributeList: Record<string, SparkAttributeInfo>;
1505
+ /**
1506
+ * Milliseconds since the session start, the timeline every entry's startTime is on. Only Metrics
1507
+ * makes one: metrics.now(), or metrics.toSessionTime() for a performance.now() time or an Event.
1508
+ */
1509
+ export declare type SessionTime = number & {
1510
+ readonly [sessionTimeBrand]: true;
1511
+ };
1512
+
1513
+ declare const sessionTimeBrand: unique symbol;
1514
+
1515
+ declare interface SharkInfo {
1516
+ renderCalls: number;
1517
+ render: SharkRenderInfo;
1518
+ reset(): void;
1519
+ }
1520
+
1521
+ declare interface SharkModule {
1522
+ Camera: new () => Camera_2;
1523
+ ClusterLodDrawState: new () => ClusterLodDrawState;
1524
+ ClusterLodResidualPages: new (
1525
+ fetch: ClusterLodResidualPageFetch,
1526
+ ) => ClusterLodResidualPages;
1527
+ RenderState: new () => RenderState;
1528
+ SplatSet: new () => SplatSet;
1529
+ GlassMeshRegistry: new () => GlassMeshRegistry;
1530
+ TrainedMeshStreamRegistry: new () => TrainedMeshStreamRegistry;
1531
+ vec4: new (x: number, y: number, z: number, w: number) => vec4;
1532
+
1533
+ SortType: {
1534
+ RADIX_SORT: SortTypeValue;
1535
+ OCTREE_SORT: SortTypeValue;
1536
+ KDTREE_SORT: SortTypeValue;
1537
+ STD_SORT: SortTypeValue;
1538
+ };
1539
+
1540
+ TextureFormat: {
1541
+ RGBA32_Float: TextureFormatValue;
1542
+ RGBA16_Float: TextureFormatValue;
1543
+ RG16_Float: TextureFormatValue;
1544
+ RGBA32_UInt: TextureFormatValue;
1545
+ RGBA32_SInt: TextureFormatValue;
1546
+ RGBA16_UInt: TextureFormatValue;
1547
+ RGBA16_SInt: TextureFormatValue;
1548
+ RGBA8_UInt: TextureFormatValue;
1549
+ RGBA8_SInt: TextureFormatValue;
1550
+ RGBA8_UNorm: TextureFormatValue;
1551
+ RGBA8_SNorm: TextureFormatValue;
1552
+ RGBA16_UNorm: TextureFormatValue;
1553
+ RGBA16_SNorm: TextureFormatValue;
1554
+ BGRA8_UNorm: TextureFormatValue;
1555
+ BC6HRGB_UFloat: TextureFormatValue;
1556
+ BC6HRGB_Float: TextureFormatValue;
1557
+ BC7RGBA_UNorm: TextureFormatValue;
1558
+ BC7RGBA_UNormSrgb: TextureFormatValue;
1559
+ BC3RGBA_UNorm: TextureFormatValue;
1560
+ BC3RGBA_UNormSrgb: TextureFormatValue;
1561
+ Depth16Unorm: TextureFormatValue;
1562
+ Depth24Plus: TextureFormatValue;
1563
+ Depth32Float: TextureFormatValue;
1564
+ };
1565
+
1566
+ WebGPU: WebGPUInterface;
1567
+
1568
+ // HEAPU8 is replaced whenever the heap grows, so read it fresh rather than caching it.
1569
+ _malloc(byteCount: number): number;
1570
+ _free(ptr: number): void;
1571
+ readonly HEAPU8: Uint8Array;
1572
+
1573
+ uploadSplatSetData(
1574
+ set: SplatSet,
1575
+ renderState: RenderState,
1576
+ start: number,
1577
+ ): void;
1578
+ uploadChunkFades(set: SplatSet, renderState: RenderState): void;
1579
+ // One mat4 per model root, so cheap enough to call every frame while an asset is moving
1580
+ uploadModelRootTransforms(set: SplatSet, renderState: RenderState): void;
1581
+ processSplatSet(
1582
+ camera: Camera_2,
1583
+ set: SplatSet,
1584
+ renderState: RenderState,
1585
+ width: number,
1586
+ height: number,
1587
+ triangles: number,
1588
+ projectOnGPU: boolean,
1589
+ cullEllipsoid: boolean,
1590
+ useAffineApprox: boolean,
1591
+ depthSortOnGPU: boolean,
1592
+ useInvZ: boolean,
1593
+ rasterizeWithCompute: boolean,
1594
+ useSOGS: boolean,
1595
+ sortType: SortTypeValue,
1596
+ skipSort: boolean,
1597
+ ): number;
1598
+ createRendererWGPUWithoutSurface(
1599
+ colorTargetFormat: TextureFormatValue,
1600
+ ): RendererWGPU;
1601
+ /// Gives back the reference WebGPU.importJsTexture returned for a texture.
1602
+ releaseImportedTexture(texture: number): void;
1603
+ renderSplatSetToSceneTextures(
1604
+ splatSet: SplatSet,
1605
+ renderState: RenderState,
1606
+ colorTarget: number,
1607
+ depthTarget: number,
1608
+ renderGES: boolean,
1609
+ ): void;
1610
+ // Render view registry, indexed as RenderViews.h orders it. setRenderView ignores an index
1611
+ // Shark cannot produce.
1612
+ setRenderView(viewIndex: number): void;
1613
+ renderView(): number;
1614
+ renderViewCount(): number;
1615
+ renderViewName(viewIndex: number): string;
1616
+ renderViewSupported(viewIndex: number): boolean;
1617
+ // The next supported view, forwards for direction 1 and backwards for -1.
1618
+ stepRenderView(from: number, direction: number): number;
1619
+ // Mesh Views, TrainedMesh.h's TRAINED_MESH_VIEW_* in order.
1620
+ trainedMeshViewCount(): number;
1621
+ trainedMeshViewName(view: number): string;
1622
+ isTrainedMeshLossView(view: number): boolean;
1623
+ isTrainedMeshOverrideColourView(view: number): boolean;
1624
+ }
1625
+
1626
+ declare interface SharkRenderInfo {
1627
+ triangles: number;
1628
+ }
1629
+
1630
+ export declare interface SnapshotData {
1631
+ readonly averageMainThreadTime: number;
1632
+ readonly averageActiveStreamCount: number;
1633
+ readonly averageFps: number;
1634
+ readonly averageVisibleNodes: number;
1635
+ readonly averageVisibleSplats: number;
1636
+ readonly averageCacheUsedBytes: number;
1637
+ readonly averageHeapUsedBytes: number;
1638
+ readonly averageHeapTotalBytes: number;
1639
+ }
1640
+
1641
+ export declare class SnapshotEntry extends Entry {
1642
+ #private;
1643
+ static [Symbol.hasInstance](value: unknown): value is MetricsSnapshotEntry;
1644
+ constructor(init: SnapshotEntryInit);
1645
+ /* Excluded from this release type: _enqueue */
1646
+ }
1647
+
1648
+ export declare type SnapshotEntryInit = EntryInit & {
1649
+ duration: DOMHighResTimeStamp;
1650
+ data: SnapshotData;
1651
+ };
1652
+
1653
+ declare interface SortTypeValue {
1654
+ value: number;
1655
+ }
1656
+
1657
+ /** @deprecated Use clientAttributeList. */
1658
+ export declare const sparkAttributeList: Record<string, ClientAttributeInfo>;
624
1659
 
625
1660
  declare interface SpatialFormat extends EmbindObject {
626
1661
  metersPerUnit: number;
@@ -629,11 +1664,89 @@ declare interface SpatialFormat extends EmbindObject {
629
1664
  handedness: number;
630
1665
  }
631
1666
 
1667
+ declare interface SplatSet {
1668
+ splatCount: number;
1669
+ // Number of splats actually drawn: ordering[0, activeSplats) holds the unmasked splat indices.
1670
+ // Set alongside orderingView() to restrict the draw to unmasked octant ranges.
1671
+ activeSplats: number;
1672
+ // Selects which ellipsoid layout to allocate and what ellipsoidsView() exposes:
1673
+ // packed (16 bytes/splat) or uncompressed (48). Must be set before the first resize.
1674
+ usePackedEllipsoids: boolean;
1675
+ // direct-write upload: resize -> write into the views -> finalize.
1676
+ // views are valid only until the next resize.
1677
+ resize(splatCount: number): void;
1678
+ ellipsoidsView(): Uint32Array;
1679
+ colorsView(): Uint32Array;
1680
+ sh1View(): Uint32Array;
1681
+ sh2View(): Uint32Array;
1682
+ sh3aView(): Uint32Array;
1683
+ sh3bView(): Uint32Array;
1684
+ // mod_depth is a half-float per primitive slot (dense, padded for non-surfels), so this is a
1685
+ // Uint16Array unlike every other view here -- do not address it with the uint32 splat strides
1686
+ // used for ellipsoids/colors/sh*.
1687
+ modDepthView(): Uint16Array;
1688
+ // Per-chunk fade (opacity multiplier), one float per chunk, defaults to 1.0.
1689
+ // Also sizes the chunk slot to model root slot map below, since both are indexed by chunk slot
1690
+ resizeChunkFades(chunkCount: number): void;
1691
+ chunkFadesView(): Float32Array;
1692
+ // Per-splat chunk index, defaults to slot 0. Write before finalize()
1693
+ chunkIndicesView(): Int32Array;
1694
+ // Model transforms, resolved per splat as
1695
+ // modelRootTransforms[chunkModelRoots[chunkIndices[splat]]]
1696
+ // Slot 0 of both tables is reserved as identity, so real slots start at 1 and a set that
1697
+ // never writes them renders untransformed.
1698
+ resizeModelRootSlots(modelRootCount: number): void;
1699
+ // 16 floats per model root, COLUMN-major - i.e. write THREE's Matrix4.toArray() straight in
1700
+ modelRootTransformsView(): Float32Array;
1701
+ // The inverses, same slots and layout. The true-perspective projection (Project.glsl) transforms
1702
+ // a quadratic form and needs them; writing a transform without its inverse leaves that path
1703
+ // projecting the splat as if untransformed. Use Matrix4.invert() on a copy
1704
+ modelRootInverseTransformsView(): Float32Array;
1705
+ // Sized by resizeChunkFades. Defaults to slot 0 (identity) for every chunk
1706
+ chunkModelRootsView(): Int32Array;
1707
+ // resizeModelRootSlots resets every slot to the absolute decode. False for a slot outside the table
1708
+ setModelRootRootRelativeDecode(
1709
+ slot: number,
1710
+ originX: number,
1711
+ originY: number,
1712
+ originZ: number,
1713
+ step: number,
1714
+ lnScaleOffset: number,
1715
+ ): boolean;
1716
+ // int32 render-order buffer (sized 2*splatCount after finalize). Valid only until the next resize.
1717
+ orderingView(): Int32Array;
1718
+ finalize(): void;
1719
+ // like finalize() but keeps splats in their delivered (octant-sorted) order — no kd-tree reorder —
1720
+ // so sparse-octant range masking can index child-octant ranges directly. RADIX_SORT only.
1721
+ finalizeBounds(): void;
1722
+ // Whether the asset carries per-surfel reflectance records, which is what decides whether
1723
+ // reflections are shaded at all. Pass to RenderState.uploadReflectionLadderParams.
1724
+ hasReflectionParams(): boolean;
1725
+ // Widens packed reflectance records - recordVersion 2 for 18-byte reflectanceDataV2, 1 for
1726
+ // 26-byte reflectanceDataV1 - into the per-splat GPU records at bufferOffset. wirePtr must
1727
+ // address THIS module's heap - _malloc here and copy the bytes in, since the attribute lives in
1728
+ // the engine module's. Records cover a node's surfel range, which starts at its first splat.
1729
+ // Returns the records written; 0 if the data was rejected.
1730
+ decodeReflectionParams(
1731
+ recordVersion: number,
1732
+ wirePtr: number,
1733
+ wireSizeBytes: number,
1734
+ elementCount: number,
1735
+ bufferOffset: number,
1736
+ nodeSplatCount: number,
1737
+ logId: number,
1738
+ ): number;
1739
+ // Zeroes records in [startSplat, endSplat). Needed wherever splats are re-packed at fresh
1740
+ // offsets, or a reused slot shades its splat from the previous occupant's material.
1741
+ clearReflectionParams(startSplat: number, endSplat: number): void;
1742
+ // Splats in [0, count) holding a non-zero record. Diagnostic.
1743
+ populatedReflectionParamCount(count: number): number;
1744
+ delete(): void;
1745
+ }
1746
+
632
1747
  export declare class Stream extends EventTarget {
633
1748
  #private;
634
- static readonly _idMap: Map<number, Stream>;
635
1749
  static readonly _keyMap: Map<unknown, Stream>;
636
- static forId(id?: number): Stream | undefined;
637
1750
  static forKey(key: unknown): Stream | undefined;
638
1751
  readonly id: number;
639
1752
  readonly scene: Scene;
@@ -651,6 +1764,9 @@ export declare class Stream extends EventTarget {
651
1764
  set matrix(matrix: Matrix4x4Tuple);
652
1765
  get opacity(): number;
653
1766
  set opacity(opacity: number);
1767
+ get fetchMode(): StreamFetchMode;
1768
+ set fetchMode(fetchMode: StreamFetchMode);
1769
+ /* Excluded from this release type: _applyFetchMode */
654
1770
  get boundingBox(): {
655
1771
  min: {
656
1772
  x: number;
@@ -683,11 +1799,23 @@ export declare class Stream extends EventTarget {
683
1799
  /* Excluded from this release type: _onStreamLoaded */
684
1800
  getDefaultCameraTransform(): Float32Array<ArrayBuffer> | null | undefined;
685
1801
  /* Excluded from this release type: _getViewingVolumeObb */
1802
+ /** How much of the stream has loaded, as of the last frame. */
1803
+ get readyState(): ReadyState_2;
1804
+ /* Excluded from this release type: _updateStatus */
686
1805
  /* Excluded from this release type: _onRootLoaded */
687
1806
  add(modelRoot: ModelRoot): void;
688
1807
  end(): void;
689
1808
  }
690
1809
 
1810
+ /**
1811
+ * What the engine will do with stream data: "regular" fetches and draws what the
1812
+ * camera needs. "prefetch" keeps fetching for the camera into the cache but does not change what is drawn.
1813
+ * "parked" fetches nothing and draws nothing, giving its share of the splat budget and
1814
+ * renderer to the other streams; what it already loaded stays cached on the cpu side for when it is unparked.
1815
+ * You may want to park streams while making them invisible.
1816
+ */
1817
+ export declare type StreamFetchMode = "regular" | "prefetch" | "parked";
1818
+
691
1819
  export declare type StreamInit = {
692
1820
  uuid: string;
693
1821
  scene: Scene;
@@ -697,6 +1825,107 @@ export declare type StreamInit = {
697
1825
 
698
1826
  declare type StringVector = EmbindVector<string>;
699
1827
 
1828
+ export declare type TargetType = MetricsTargetType;
1829
+
1830
+ export declare type TelemetryTarget = MirisTarget | SceneTarget | ObjectTarget;
1831
+
1832
+ declare interface TextureFormatValue {
1833
+ value: number;
1834
+ }
1835
+
1836
+ declare const TIMING_NAME_ORDINAL: {
1837
+ readonly initialize: 0;
1838
+ readonly load: 1;
1839
+ readonly "first-pixel": 2;
1840
+ readonly stable: 3;
1841
+ readonly decode: 4;
1842
+ };
1843
+
1844
+ export declare class TimingEntry extends Entry {
1845
+ #private;
1846
+ static [Symbol.hasInstance](value: unknown): value is MetricsTimingEntry;
1847
+ constructor(init: TimingEntryInit);
1848
+ /* Excluded from this release type: _enqueue */
1849
+ }
1850
+
1851
+ export declare type TimingEntryInit = EntryInit & {
1852
+ target: TelemetryTarget;
1853
+ name: TimingEntryName;
1854
+ duration: DOMHighResTimeStamp;
1855
+ };
1856
+
1857
+ export declare type TimingEntryName = keyof typeof TIMING_NAME_ORDINAL;
1858
+
1859
+ declare interface TrainedMeshStreamRegistry {
1860
+ registerMesh(objectId: number, bytesPtr: number, byteCount: number): boolean;
1861
+ registerDecoder(
1862
+ decoderPtr: number,
1863
+ decoderByteCount: number,
1864
+ mapPtr: number,
1865
+ mapByteCount: number,
1866
+ ): boolean;
1867
+ // ALOS per-vertex training loss, which the loss overlay writes into features0.
1868
+ registerLoss(bytesPtr: number, byteCount: number): boolean;
1869
+ setLossOverlay(enabled: boolean): void;
1870
+ hasLoss(): boolean;
1871
+ // The loss a channel's (p10, p50, p90) level 0 and level 1 stand for, or -1 without loss.
1872
+ lossLow(channel: number): number;
1873
+ lossHigh(channel: number): number;
1874
+ // vertexCount RGB bytes a vertex for one (piece, level) copy, kept across streaming; false for a
1875
+ // count other than the drawn copy's. Copied before returning.
1876
+ setPieceColours(
1877
+ pieceId: number,
1878
+ level: number,
1879
+ rgbPtr: number,
1880
+ vertexCount: number,
1881
+ ): boolean;
1882
+ clearColours(): void;
1883
+ // On, the "Override colour" Mesh View draws the supplied colours, magenta for a copy without.
1884
+ setColourOverride(enabled: boolean): void;
1885
+ isColourOverride(): boolean;
1886
+ // As "id,level,vertexCount;...": the copies in one node, or in every resident node.
1887
+ nodePieces(objectId: number): string;
1888
+ residentPieces(): string;
1889
+ removeObject(objectId: number): boolean;
1890
+ clear(): void;
1891
+ isDrawable(): boolean;
1892
+ uploadIfChanged(renderState: RenderState): void;
1893
+ // For a mesh drawn from a cluster LOD pool, which has no pieces to upload the decoder with.
1894
+ uploadDecoderAlone(renderState: RenderState): void;
1895
+ drawTriangleCount(): number;
1896
+ residentNodeCount(): number;
1897
+ residentPayloadBytes(): number;
1898
+ drawnPiecesByLevel(): string;
1899
+ // As of the last upload: the drawn piece ids ascending as "a;b;c", and the node drawing a piece
1900
+ // (-1 for none).
1901
+ drawnPieceIds(): string;
1902
+ drawnPieceObjectId(pieceId: number): number;
1903
+ // The drawn piece a ray in the mesh's own frame hits first, or -1.
1904
+ pickPiece(
1905
+ originX: number,
1906
+ originY: number,
1907
+ originZ: number,
1908
+ directionX: number,
1909
+ directionY: number,
1910
+ directionZ: number,
1911
+ ): number;
1912
+ delete(): void;
1913
+ }
1914
+
1915
+ export declare class TransformationEntry extends Entry {
1916
+ #private;
1917
+ static [Symbol.hasInstance](value: unknown): value is MetricsTransformationEntry;
1918
+ constructor(init: TransformationEntryInit);
1919
+ /* Excluded from this release type: _enqueue */
1920
+ }
1921
+
1922
+ export declare type TransformationEntryInit = EntryInit & {
1923
+ target: ObjectTarget;
1924
+ position: [number, number, number];
1925
+ quaternion: [number, number, number, number];
1926
+ scale: [number, number, number];
1927
+ };
1928
+
700
1929
  /** Recursive variant tree node from WASM. */
701
1930
  export declare type VariantNode = {
702
1931
  id: number;
@@ -707,4 +1936,18 @@ export declare type VariantNode = {
707
1936
  nestedSets?: VariantNode[];
708
1937
  };
709
1938
 
1939
+ declare interface vec4 {
1940
+ x: number;
1941
+ y: number;
1942
+ z: number;
1943
+ w: number;
1944
+ delete(): void;
1945
+ }
1946
+
1947
+ declare interface WebGPUInterface {
1948
+ importJsAdapter(adapter: GPUAdapter, parentPtr?: number): number;
1949
+ importJsDevice(device: GPUDevice, parentPtr?: number): number;
1950
+ importJsTexture(obj: GPUTexture, parentPtr?: number): number;
1951
+ }
1952
+
710
1953
  export { }