@miris-inc/core 0.0.8-e3edc7d → 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/AquaApi.wasm +0 -0
- package/dist/aqua-parser.wasm +0 -0
- package/dist/core.d.ts +1191 -18
- package/dist/core.js +1568 -495
- package/dist/core.prod.js +1 -1
- package/dist/core.standalone.js +4544 -2560
- package/dist/core.standalone.prod.js +1 -1
- package/package.json +1 -5
- package/dist/webshark.d.ts +0 -327
- package/dist/webshark.js +0 -2
- package/dist/webshark.wasm +0 -0
package/dist/core.d.ts
CHANGED
|
@@ -40,6 +40,7 @@ export declare class AttributeNames {
|
|
|
40
40
|
static readonly REFLECTANCE_DATA_V2: string;
|
|
41
41
|
static readonly GLASS_MESH_GEOMETRY: string;
|
|
42
42
|
static readonly GLASS_MESH_PANELS: string;
|
|
43
|
+
static readonly TRAINED_MESH: string;
|
|
43
44
|
static readonly MOD_DEPTH: string;
|
|
44
45
|
}
|
|
45
46
|
|
|
@@ -70,6 +71,18 @@ export declare class Camera {
|
|
|
70
71
|
constructor({ aspect, fov, near, far, matrix, scene, viewportHeight, }: CameraInit);
|
|
71
72
|
}
|
|
72
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
|
+
|
|
73
86
|
export declare type CameraInit = {
|
|
74
87
|
aspect: number;
|
|
75
88
|
fov: number;
|
|
@@ -97,7 +110,7 @@ declare class Client {
|
|
|
97
110
|
readonly handle: AquaClientHandle;
|
|
98
111
|
get viewerKey(): string | null;
|
|
99
112
|
set viewerKey(key: string | null);
|
|
100
|
-
constructor({ engine, context }: ClientInit);
|
|
113
|
+
constructor({ engine, context, id, telemetryCollector }: ClientInit);
|
|
101
114
|
dispose(): void;
|
|
102
115
|
addStreamById(...args: ClientMethodParameters["addStreamById"]): number;
|
|
103
116
|
destroyClient(...args: ClientMethodParameters["destroyClient"]): AquaStatus;
|
|
@@ -116,6 +129,11 @@ declare class Client {
|
|
|
116
129
|
getStreamStatus(...args: ClientMethodParameters["getStreamStatus"]): StreamStatus;
|
|
117
130
|
getDrawnOctantMask(...args: ClientMethodParameters["getDrawnOctantMask"]): number;
|
|
118
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;
|
|
119
137
|
getLocalTransform(...args: ClientMethodParameters["getLocalTransform"]): AquaStatus;
|
|
120
138
|
getWorldTransform(...args: ClientMethodParameters["getWorldTransform"]): AquaStatus;
|
|
121
139
|
hasAttribute(...args: ClientMethodParameters["hasAttribute"]): boolean;
|
|
@@ -125,6 +143,8 @@ declare class Client {
|
|
|
125
143
|
setAssetViewerKey(...args: ClientMethodParameters["setAssetViewerKey"]): AquaStatus;
|
|
126
144
|
setClientSpatialFormat(...args: ClientMethodParameters["setClientSpatialFormat"]): AquaStatus;
|
|
127
145
|
setRuntimeSettings(...args: ClientMethodParameters["setRuntimeSettings"]): AquaStatus;
|
|
146
|
+
setStreamFetchMode(...args: ClientMethodParameters["setStreamFetchMode"]): boolean;
|
|
147
|
+
getStreamFetchMode(...args: ClientMethodParameters["getStreamFetchMode"]): number;
|
|
128
148
|
setMainCameraTransform(...args: ClientMethodParameters["setMainCameraTransform"]): AquaStatus;
|
|
129
149
|
setMainCameraViewFrustum(...args: ClientMethodParameters["setMainCameraViewFrustum"]): AquaStatus;
|
|
130
150
|
setSceneObjectTransform(...args: ClientMethodParameters["setSceneObjectTransform"]): AquaStatus;
|
|
@@ -142,15 +162,177 @@ declare class Client {
|
|
|
142
162
|
updateSceneExecution(...args: ClientMethodParameters["updateSceneExecution"]): AquaStatus;
|
|
143
163
|
}
|
|
144
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
|
+
|
|
145
173
|
declare type ClientInit = {
|
|
146
174
|
engine: Engine;
|
|
147
175
|
context?: AquaContextHandle;
|
|
176
|
+
id: number;
|
|
177
|
+
/** Must outlive the client. */
|
|
178
|
+
telemetryCollector?: AquaTelemetryCollectorHandle;
|
|
148
179
|
};
|
|
149
180
|
|
|
150
181
|
declare type ClientMethodParameters<Parameters extends EngineMethodParameters = EngineMethodParameters> = {
|
|
151
182
|
[Key in keyof Parameters]: Parameters[Key] extends [any, ...infer Rest] ? Rest : [];
|
|
152
183
|
};
|
|
153
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
|
+
|
|
154
336
|
declare interface EmbindObject {
|
|
155
337
|
delete(): void;
|
|
156
338
|
}
|
|
@@ -186,11 +368,16 @@ declare class Engine {
|
|
|
186
368
|
readonly VariantSetCollection: 7;
|
|
187
369
|
readonly VariantSet: 8;
|
|
188
370
|
readonly VariantSetOption: 9;
|
|
371
|
+
readonly ClusterLodMesh: 10;
|
|
189
372
|
};
|
|
190
373
|
static Feature: {
|
|
191
374
|
readonly DrMap: 0;
|
|
192
375
|
readonly ReflMesh: 1;
|
|
193
376
|
readonly GlassMesh: 2;
|
|
377
|
+
readonly NeuralMaterialDecoder: 3;
|
|
378
|
+
readonly DirectionalFeatureMap: 4;
|
|
379
|
+
readonly VertexLoss: 5;
|
|
380
|
+
readonly RenderAsPointCloud: 6;
|
|
194
381
|
};
|
|
195
382
|
static FeatureState: {
|
|
196
383
|
readonly NotLoaded: 0;
|
|
@@ -205,6 +392,11 @@ declare class Engine {
|
|
|
205
392
|
readonly Ready: 3;
|
|
206
393
|
readonly Failed: 4;
|
|
207
394
|
};
|
|
395
|
+
static StreamFetchMode: {
|
|
396
|
+
readonly Regular: 0;
|
|
397
|
+
readonly Prefetch: 1;
|
|
398
|
+
readonly Parked: 2;
|
|
399
|
+
};
|
|
208
400
|
readonly ready: Promise<this>;
|
|
209
401
|
readonly pending: boolean;
|
|
210
402
|
get module(): MainModule;
|
|
@@ -235,6 +427,7 @@ declare class Engine {
|
|
|
235
427
|
Y: number;
|
|
236
428
|
Z: number;
|
|
237
429
|
};
|
|
430
|
+
get UsePadding(): boolean;
|
|
238
431
|
activatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
239
432
|
addStreamById(...args: [
|
|
240
433
|
handle: AquaClientHandle,
|
|
@@ -245,7 +438,8 @@ declare class Engine {
|
|
|
245
438
|
allocateSceneChangesArrays(...args: [sceneChangeIds: SceneChangeIds]): void;
|
|
246
439
|
createContext(...args: []): AquaContextHandle;
|
|
247
440
|
destroyContext(...args: [handle: AquaContextHandle]): AquaStatus;
|
|
248
|
-
|
|
441
|
+
/** telemetryCollector, a collector handle or 0 for none, must outlive the client. */
|
|
442
|
+
createClient(id: number, context?: AquaContextHandle, telemetryCollector?: number): AquaClientHandle;
|
|
249
443
|
createdObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
250
444
|
deletedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
251
445
|
dataPtrView(...args: [attributeInfo: AttributeInfo]): Uint32Array;
|
|
@@ -253,6 +447,17 @@ declare class Engine {
|
|
|
253
447
|
remaskedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
254
448
|
getDrawnOctantMask(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
|
|
255
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;
|
|
256
461
|
destroyClient(...args: [handle: AquaClientHandle]): AquaStatus;
|
|
257
462
|
free(...args: [size: number]): number;
|
|
258
463
|
getAssetsAsync(...args: [handle: AquaClientHandle, tags: StringVector]): AssetInfo[];
|
|
@@ -323,8 +528,140 @@ declare class Engine {
|
|
|
323
528
|
farPlane: number,
|
|
324
529
|
viewportHeightPixels: number
|
|
325
530
|
]): AquaStatus;
|
|
531
|
+
setStreamFetchMode(...args: [handle: AquaClientHandle, streamObjectId: number, mode: number]): boolean;
|
|
532
|
+
getStreamFetchMode(...args: [handle: AquaClientHandle, streamObjectId: number]): number;
|
|
326
533
|
setMaxCacheSize(...args: [maxSizeBytes: number]): void;
|
|
327
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[];
|
|
328
665
|
setSceneObjectTransform(...args: [
|
|
329
666
|
handle: AquaClientHandle,
|
|
330
667
|
sceneObjectId: number,
|
|
@@ -353,9 +690,16 @@ declare class Engine {
|
|
|
353
690
|
* displayed frame per context, before the per-client updateSceneExecution() calls.
|
|
354
691
|
* `previousFrameTimeMs` is how long the previous frame took; pass 0 when there is no plausible
|
|
355
692
|
* measurement (first frame, or a resume from a stall) and the frame advances without recording
|
|
356
|
-
*
|
|
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.
|
|
357
696
|
*/
|
|
358
|
-
beginFrame(...args: [
|
|
697
|
+
beginFrame(...args: [
|
|
698
|
+
contextHandle: AquaContextHandle,
|
|
699
|
+
previousFrameTimeMs: number,
|
|
700
|
+
primsResident: number,
|
|
701
|
+
primCapacity: number
|
|
702
|
+
]): AquaStatus;
|
|
359
703
|
createDeserializeWorker(_url: string, _workerUrl: string, poolSize: number): boolean;
|
|
360
704
|
cancelRequest(requestIdLow: number, requestIdHigh: number): boolean;
|
|
361
705
|
submitToWorker(requestIdLow: number, requestIdHigh: number, descriptorBuffer: ArrayBuffer, contextPtr: number): boolean;
|
|
@@ -369,12 +713,175 @@ declare type EngineMethodParameters<E extends Engine = Engine> = {
|
|
|
369
713
|
[Key in keyof E]: E[Key] extends (...args: any[]) => any ? Parameters<E[Key]> : never;
|
|
370
714
|
};
|
|
371
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
|
+
|
|
372
803
|
export declare const HaveData = 2;
|
|
373
804
|
|
|
374
805
|
export declare const HaveMetadata = 1;
|
|
375
806
|
|
|
376
807
|
export declare const HaveNothing = 0;
|
|
377
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
|
+
|
|
378
885
|
export declare class Lod {
|
|
379
886
|
#private;
|
|
380
887
|
readonly id: LodInit["id"];
|
|
@@ -440,7 +947,7 @@ export declare class LodStore {
|
|
|
440
947
|
deleteId(id: number): void;
|
|
441
948
|
}
|
|
442
949
|
|
|
443
|
-
declare interface MainModule {
|
|
950
|
+
declare interface MainModule extends SharkModule {
|
|
444
951
|
AttributeInfo: new () => AttributeInfo;
|
|
445
952
|
CompressionType: {
|
|
446
953
|
SHARK_ELLIPSOID_COMPRESSED: unknown;
|
|
@@ -476,25 +983,212 @@ declare interface MainModule {
|
|
|
476
983
|
deletedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
|
|
477
984
|
GetDrawnOctantMask(handle: number, sceneObjectId: number): number;
|
|
478
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;
|
|
479
997
|
GetAssetsAsync(handle: number, tags: StringVector): unknown[];
|
|
480
998
|
GetSceneChanges(handle: number, sceneChangeIds: SceneChangeIds): void;
|
|
481
999
|
GetSceneChangesCounts(handle: number, sceneChangeIds: SceneChangeIds): void;
|
|
482
1000
|
GetSceneMetadata(handle: number, metadata: SceneMetadata): { value: number };
|
|
483
1001
|
GetName(handle: number, sceneObjectId: number): string;
|
|
484
1002
|
HasFeature(handle: number, sceneObjectId: number, feature: number): boolean;
|
|
485
|
-
GetFeatureVersion(
|
|
486
|
-
|
|
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;
|
|
487
1013
|
GetAssetFormatVersion(handle: number, sceneObjectId: number): number;
|
|
488
|
-
GetDrMapLadderRoughnessLevels(
|
|
489
|
-
|
|
490
|
-
|
|
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;
|
|
491
1032
|
TakeEvictedClientSideAttributeIds(handle: number): EmbindVector<bigint>;
|
|
492
1033
|
GetActiveClientSideIdsCheckSum(): number;
|
|
493
1034
|
TakeRenderRequired(handle: number): boolean;
|
|
494
|
-
BeginFrame(
|
|
1035
|
+
BeginFrame(
|
|
1036
|
+
contextHandle: number,
|
|
1037
|
+
previousFrameTimeMs: number,
|
|
1038
|
+
primsResident: number,
|
|
1039
|
+
primCapacity: number,
|
|
1040
|
+
): number;
|
|
495
1041
|
modifiedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
|
|
496
1042
|
setMaxCacheSize(maxSizeBytes: number): void;
|
|
497
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];
|
|
498
1192
|
}
|
|
499
1193
|
|
|
500
1194
|
/**
|
|
@@ -509,14 +1203,23 @@ export declare class Miris {
|
|
|
509
1203
|
#private;
|
|
510
1204
|
static tryUseShark: boolean;
|
|
511
1205
|
static _instance: Miris;
|
|
1206
|
+
/** The package this Miris reports in configuration/miris. */
|
|
1207
|
+
static readonly package: MirisPackage;
|
|
512
1208
|
static instance<T extends typeof Miris>(this: T): Promise<InstanceType<T>>;
|
|
513
1209
|
readonly engine: Engine;
|
|
514
1210
|
readonly ready: Promise<this>;
|
|
515
1211
|
readonly pending: boolean;
|
|
1212
|
+
/** Unique within the telemetry session; defined once `ready` resolves, if it joined one. */
|
|
1213
|
+
readonly id: number;
|
|
516
1214
|
get sharedContext(): number | undefined;
|
|
1215
|
+
get telemetryCollector(): number | undefined;
|
|
1216
|
+
get metrics(): Metrics;
|
|
517
1217
|
get viewerKey(): string | null | undefined;
|
|
518
1218
|
set viewerKey(viewerKey: string | null | undefined);
|
|
519
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 */
|
|
520
1223
|
get useSphericalHarmonics(): boolean;
|
|
521
1224
|
set useSphericalHarmonics(value: boolean);
|
|
522
1225
|
constructor();
|
|
@@ -526,6 +1229,7 @@ export declare class Miris {
|
|
|
526
1229
|
protected _xrSession: XRSession | null;
|
|
527
1230
|
protected _requestAnimationFrame: RequestAnimationFrameFn | null;
|
|
528
1231
|
signalResumeFromIdle(): void;
|
|
1232
|
+
/* Excluded from this release type: _enableClusterLod */
|
|
529
1233
|
get _splatCountBudget(): number;
|
|
530
1234
|
/**
|
|
531
1235
|
* Why 43? Because the AVP throttles down to 45Hz :(
|
|
@@ -536,13 +1240,18 @@ export declare class Miris {
|
|
|
536
1240
|
static readonly _SHARK_SPLAT_CAPACITY_DESKTOP: number;
|
|
537
1241
|
/* Excluded from this release type: _SHARK_SPLAT_BUDGET_CAP_MOBILE */
|
|
538
1242
|
static readonly _SHARK_SPLAT_BUDGET_CAP_DESKTOP = 2400000;
|
|
1243
|
+
/* Excluded from this release type: _CLUSTER_LOD_POOL_BYTES_MOBILE */
|
|
539
1244
|
/* Excluded from this release type: _isMobileDevice */
|
|
540
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 */
|
|
541
1249
|
/* Excluded from this release type: _limitSharkSplatCapacity */
|
|
542
1250
|
/* Excluded from this release type: _sharkSplatBudgetCap */
|
|
543
1251
|
/* Excluded from this release type: _setTargetFrameRate */
|
|
544
1252
|
/* Excluded from this release type: _setXRModeActive */
|
|
545
1253
|
/* Excluded from this release type: _setSplatCountBudgetOverride */
|
|
1254
|
+
/* Excluded from this release type: _reportRendererPrims */
|
|
546
1255
|
/* Excluded from this release type: _update */
|
|
547
1256
|
getLocalTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
|
|
548
1257
|
getWorldTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
|
|
@@ -554,10 +1263,16 @@ export declare class Miris {
|
|
|
554
1263
|
delete(scene: Scene): void;
|
|
555
1264
|
}
|
|
556
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
|
+
|
|
557
1273
|
export declare class ModelRoot {
|
|
558
1274
|
#private;
|
|
559
1275
|
static forKey(key: unknown): ModelRoot | undefined;
|
|
560
|
-
static forId(id: number): ModelRoot | undefined;
|
|
561
1276
|
readonly id: ModelRootInit["id"];
|
|
562
1277
|
get key(): unknown;
|
|
563
1278
|
set key(key: unknown);
|
|
@@ -575,6 +1290,20 @@ export declare type ModelRootInit = {
|
|
|
575
1290
|
stream: Stream;
|
|
576
1291
|
};
|
|
577
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
|
+
|
|
578
1307
|
/**
|
|
579
1308
|
* The byte-exact counterpart of getRawUint32Attribute above: same no-padding, no-takeAttribute
|
|
580
1309
|
* contract, returning bytes rather than words.
|
|
@@ -600,6 +1329,80 @@ export declare type RawByteAttributeWithBounds = {
|
|
|
600
1329
|
declare type ReadyState_2 = typeof HaveNothing | typeof HaveMetadata | typeof HaveData;
|
|
601
1330
|
export { ReadyState_2 as ReadyState }
|
|
602
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
|
+
|
|
603
1406
|
declare type RequestAnimationFrameFn = ((callback: FrameRequestCallback) => number) | ((callback: XRFrameRequestCallback) => void);
|
|
604
1407
|
|
|
605
1408
|
declare interface RuntimeSettings extends EmbindObject {
|
|
@@ -609,6 +1412,10 @@ declare interface RuntimeSettings extends EmbindObject {
|
|
|
609
1412
|
xrModeActive: boolean;
|
|
610
1413
|
splatCountBudget: number;
|
|
611
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;
|
|
612
1419
|
}
|
|
613
1420
|
|
|
614
1421
|
export declare class Scene extends EventTarget {
|
|
@@ -625,6 +1432,9 @@ export declare class Scene extends EventTarget {
|
|
|
625
1432
|
set viewerKey(viewerKey: string | null);
|
|
626
1433
|
get streams(): Set<Stream>;
|
|
627
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 */
|
|
628
1438
|
readonly miris: Miris;
|
|
629
1439
|
readonly engine: Engine;
|
|
630
1440
|
readonly client: Client;
|
|
@@ -652,14 +1462,19 @@ export declare class Scene extends EventTarget {
|
|
|
652
1462
|
add(stream: Stream): void;
|
|
653
1463
|
getStreamForId(streamObjectId: number): Stream | undefined;
|
|
654
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;
|
|
655
1467
|
getModelRootForDescendentId(descendentObjectId: number): ModelRoot | null;
|
|
656
1468
|
_recordAssetFormat(modelRoot: ModelRoot, formatVersion: number): void;
|
|
657
1469
|
/* Excluded from this release type: _getFeatureMesh */
|
|
1470
|
+
/* Excluded from this release type: _takeAttributeBuffer */
|
|
658
1471
|
/* Excluded from this release type: _getDrMap */
|
|
659
1472
|
/* Excluded from this release type: _onDrMapLadder */
|
|
660
1473
|
/* Excluded from this release type: _onFeatureData */
|
|
1474
|
+
/* Excluded from this release type: _applyStreamFetchModes */
|
|
661
1475
|
/* Excluded from this release type: _updateStreamStatuses */
|
|
662
1476
|
/* Excluded from this release type: _onSceneLoaded */
|
|
1477
|
+
/* Excluded from this release type: _releaseStreamId */
|
|
663
1478
|
delete(stream: Stream): void;
|
|
664
1479
|
close(): void;
|
|
665
1480
|
}
|
|
@@ -682,12 +1497,165 @@ declare interface SceneMetadata extends EmbindObject {
|
|
|
682
1497
|
readonly inputColorSpace: string;
|
|
683
1498
|
}
|
|
684
1499
|
|
|
685
|
-
declare type
|
|
686
|
-
|
|
687
|
-
|
|
1500
|
+
export declare type SceneTarget = {
|
|
1501
|
+
readonly type: "scene";
|
|
1502
|
+
readonly id: number;
|
|
688
1503
|
};
|
|
689
1504
|
|
|
690
|
-
|
|
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>;
|
|
691
1659
|
|
|
692
1660
|
declare interface SpatialFormat extends EmbindObject {
|
|
693
1661
|
metersPerUnit: number;
|
|
@@ -696,11 +1664,89 @@ declare interface SpatialFormat extends EmbindObject {
|
|
|
696
1664
|
handedness: number;
|
|
697
1665
|
}
|
|
698
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
|
+
|
|
699
1747
|
export declare class Stream extends EventTarget {
|
|
700
1748
|
#private;
|
|
701
|
-
static readonly _idMap: Map<number, Stream>;
|
|
702
1749
|
static readonly _keyMap: Map<unknown, Stream>;
|
|
703
|
-
static forId(id?: number): Stream | undefined;
|
|
704
1750
|
static forKey(key: unknown): Stream | undefined;
|
|
705
1751
|
readonly id: number;
|
|
706
1752
|
readonly scene: Scene;
|
|
@@ -718,6 +1764,9 @@ export declare class Stream extends EventTarget {
|
|
|
718
1764
|
set matrix(matrix: Matrix4x4Tuple);
|
|
719
1765
|
get opacity(): number;
|
|
720
1766
|
set opacity(opacity: number);
|
|
1767
|
+
get fetchMode(): StreamFetchMode;
|
|
1768
|
+
set fetchMode(fetchMode: StreamFetchMode);
|
|
1769
|
+
/* Excluded from this release type: _applyFetchMode */
|
|
721
1770
|
get boundingBox(): {
|
|
722
1771
|
min: {
|
|
723
1772
|
x: number;
|
|
@@ -758,6 +1807,15 @@ export declare class Stream extends EventTarget {
|
|
|
758
1807
|
end(): void;
|
|
759
1808
|
}
|
|
760
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
|
+
|
|
761
1819
|
export declare type StreamInit = {
|
|
762
1820
|
uuid: string;
|
|
763
1821
|
scene: Scene;
|
|
@@ -767,6 +1825,107 @@ export declare type StreamInit = {
|
|
|
767
1825
|
|
|
768
1826
|
declare type StringVector = EmbindVector<string>;
|
|
769
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
|
+
|
|
770
1929
|
/** Recursive variant tree node from WASM. */
|
|
771
1930
|
export declare type VariantNode = {
|
|
772
1931
|
id: number;
|
|
@@ -777,4 +1936,18 @@ export declare type VariantNode = {
|
|
|
777
1936
|
nestedSets?: VariantNode[];
|
|
778
1937
|
};
|
|
779
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
|
+
|
|
780
1953
|
export { }
|