@miris-inc/core 0.0.8-e3fcc2a → 0.0.8-e5afd91
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 +1346 -21
- package/dist/core.js +1826 -521
- package/dist/core.prod.js +1 -1
- package/dist/core.standalone.js +4669 -2433
- package/dist/core.standalone.prod.js +1 -1
- package/package.json +1 -8
- package/webshark.d.ts +0 -249
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
|
-
|
|
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,15 @@ 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
|
+
getClusterLodGlassDrawList(...args: ClientMethodParameters["getClusterLodGlassDrawList"]): Uint32Array<ArrayBufferLike> | null;
|
|
136
|
+
hasClusterLodResidualPages(...args: ClientMethodParameters["hasClusterLodResidualPages"]): boolean | null;
|
|
137
|
+
fetchClusterLodPageFile(...args: ClientMethodParameters["fetchClusterLodPageFile"]): boolean;
|
|
110
138
|
getLocalTransform(...args: ClientMethodParameters["getLocalTransform"]): AquaStatus;
|
|
111
139
|
getWorldTransform(...args: ClientMethodParameters["getWorldTransform"]): AquaStatus;
|
|
112
140
|
hasAttribute(...args: ClientMethodParameters["hasAttribute"]): boolean;
|
|
@@ -116,6 +144,8 @@ declare class Client {
|
|
|
116
144
|
setAssetViewerKey(...args: ClientMethodParameters["setAssetViewerKey"]): AquaStatus;
|
|
117
145
|
setClientSpatialFormat(...args: ClientMethodParameters["setClientSpatialFormat"]): AquaStatus;
|
|
118
146
|
setRuntimeSettings(...args: ClientMethodParameters["setRuntimeSettings"]): AquaStatus;
|
|
147
|
+
setStreamFetchMode(...args: ClientMethodParameters["setStreamFetchMode"]): boolean;
|
|
148
|
+
getStreamFetchMode(...args: ClientMethodParameters["getStreamFetchMode"]): number;
|
|
119
149
|
setMainCameraTransform(...args: ClientMethodParameters["setMainCameraTransform"]): AquaStatus;
|
|
120
150
|
setMainCameraViewFrustum(...args: ClientMethodParameters["setMainCameraViewFrustum"]): AquaStatus;
|
|
121
151
|
setSceneObjectTransform(...args: ClientMethodParameters["setSceneObjectTransform"]): AquaStatus;
|
|
@@ -133,15 +163,203 @@ declare class Client {
|
|
|
133
163
|
updateSceneExecution(...args: ClientMethodParameters["updateSceneExecution"]): AquaStatus;
|
|
134
164
|
}
|
|
135
165
|
|
|
166
|
+
declare type ClientAttributeInfo = {
|
|
167
|
+
elementsPerSplat: number;
|
|
168
|
+
discard: boolean;
|
|
169
|
+
bytes?: true;
|
|
170
|
+
};
|
|
171
|
+
|
|
172
|
+
export declare const clientAttributeList: Record<string, ClientAttributeInfo>;
|
|
173
|
+
|
|
136
174
|
declare type ClientInit = {
|
|
137
175
|
engine: Engine;
|
|
138
176
|
context?: AquaContextHandle;
|
|
177
|
+
id: number;
|
|
178
|
+
/** Must outlive the client. */
|
|
179
|
+
telemetryCollector?: AquaTelemetryCollectorHandle;
|
|
139
180
|
};
|
|
140
181
|
|
|
141
182
|
declare type ClientMethodParameters<Parameters extends EngineMethodParameters = EngineMethodParameters> = {
|
|
142
183
|
[Key in keyof Parameters]: Parameters[Key] extends [any, ...infer Rest] ? Rest : [];
|
|
143
184
|
};
|
|
144
185
|
|
|
186
|
+
declare interface ClusterLodDrawState {
|
|
187
|
+
createPool(renderState: RenderState, info: ClusterLodPoolInfo): void;
|
|
188
|
+
releasePool(renderState: RenderState): void;
|
|
189
|
+
applyWrite(
|
|
190
|
+
renderState: RenderState,
|
|
191
|
+
vertexOffset: number,
|
|
192
|
+
verticesPtr: number,
|
|
193
|
+
vertexCount: number,
|
|
194
|
+
triangleOffset: number,
|
|
195
|
+
trianglesPtr: number,
|
|
196
|
+
triangleCount: number,
|
|
197
|
+
clusterOffset: number,
|
|
198
|
+
clustersPtr: number,
|
|
199
|
+
cullSpheresPtr: number,
|
|
200
|
+
clusterCount: number,
|
|
201
|
+
): void;
|
|
202
|
+
// Culls the cut's slots to the camera, with the mesh in the model root at modelRootIndex, and draws
|
|
203
|
+
// what is left.
|
|
204
|
+
cullAndDraw(
|
|
205
|
+
renderState: RenderState,
|
|
206
|
+
splatSet: SplatSet,
|
|
207
|
+
modelRootIndex: number,
|
|
208
|
+
camera: Camera_2,
|
|
209
|
+
width: number,
|
|
210
|
+
height: number,
|
|
211
|
+
slotsPtr: number,
|
|
212
|
+
slotCount: number,
|
|
213
|
+
): void;
|
|
214
|
+
// As cullAndDraw, for the same cut's glass slots, which the glass peel draws. Call it after
|
|
215
|
+
// cullAndDraw, with the same camera, every frame the pool has glass.
|
|
216
|
+
cullAndDrawGlass(
|
|
217
|
+
renderState: RenderState,
|
|
218
|
+
splatSet: SplatSet,
|
|
219
|
+
modelRootIndex: number,
|
|
220
|
+
camera: Camera_2,
|
|
221
|
+
width: number,
|
|
222
|
+
height: number,
|
|
223
|
+
slotsPtr: number,
|
|
224
|
+
slotCount: number,
|
|
225
|
+
): void;
|
|
226
|
+
delete(): void;
|
|
227
|
+
}
|
|
228
|
+
|
|
229
|
+
export declare interface ClusterLodFrame {
|
|
230
|
+
sceneObjectId: number;
|
|
231
|
+
modelRoot: ModelRoot;
|
|
232
|
+
info: ClusterLodPoolInfo;
|
|
233
|
+
writes: ClusterLodPoolWrite[];
|
|
234
|
+
drawList: Uint32Array;
|
|
235
|
+
glassDrawList: Uint32Array;
|
|
236
|
+
writesApplied: () => void;
|
|
237
|
+
fetchPageFile: ClusterLodPageFetch | null;
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
declare type ClusterLodPageFetch = (fileName: string, fileBytes: number, done: ClusterLodPageFileDone) => void;
|
|
241
|
+
|
|
242
|
+
declare type ClusterLodPageFileDone = (bytesPtr: number | null, byteCount: number) => void;
|
|
243
|
+
|
|
244
|
+
declare interface ClusterLodPoolInfo {
|
|
245
|
+
vertexCapacity: number;
|
|
246
|
+
triangleCapacity: number;
|
|
247
|
+
clusterCapacity: number;
|
|
248
|
+
positionMin: number[];
|
|
249
|
+
positionScale: number;
|
|
250
|
+
featureLow: number[];
|
|
251
|
+
featureHigh: number[];
|
|
252
|
+
// MOSS's glass block, which the native pool sizes its glass peel by; glassLayers is 0 without glass.
|
|
253
|
+
glassLayers: number;
|
|
254
|
+
glassSheetGap: number;
|
|
255
|
+
glassHybMode: number;
|
|
256
|
+
// The Schlick r a glass vertex's code 0 and 255 decode to.
|
|
257
|
+
reflectanceLow: number;
|
|
258
|
+
reflectanceHigh: number;
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
declare interface ClusterLodPoolWrite {
|
|
262
|
+
vertexOffset: number;
|
|
263
|
+
vertexCount: number;
|
|
264
|
+
verticesPtr: number;
|
|
265
|
+
triangleOffset: number;
|
|
266
|
+
triangleCount: number;
|
|
267
|
+
trianglesPtr: number;
|
|
268
|
+
clusterOffset: number;
|
|
269
|
+
clusterCount: number;
|
|
270
|
+
clustersPtr: number;
|
|
271
|
+
cullSpheresPtr: number;
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
declare type ClusterLodResidualPageFetch = (
|
|
275
|
+
fileName: string,
|
|
276
|
+
fileBytes: number,
|
|
277
|
+
requestId: number,
|
|
278
|
+
) => void;
|
|
279
|
+
|
|
280
|
+
declare interface ClusterLodResidualPages {
|
|
281
|
+
complete(requestId: number, bytesPtr: number, byteCount: number): void;
|
|
282
|
+
// Once a frame, after the cluster LOD pool's writes.
|
|
283
|
+
update(renderState: RenderState): void;
|
|
284
|
+
isSettled(renderState: RenderState): boolean;
|
|
285
|
+
pageCount(): number;
|
|
286
|
+
completePageCount(renderState: RenderState): number;
|
|
287
|
+
delete(): void;
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
export declare interface ConfigurationCameraData {
|
|
291
|
+
readonly aspect: number;
|
|
292
|
+
readonly fov: number;
|
|
293
|
+
readonly near: number;
|
|
294
|
+
readonly far: number;
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
export declare type ConfigurationCameraInit = Omit<ConfigurationCameraData, never>;
|
|
298
|
+
|
|
299
|
+
export declare class ConfigurationEntry extends Entry {
|
|
300
|
+
#private;
|
|
301
|
+
static [Symbol.hasInstance](value: unknown): value is MetricsConfigurationEntry;
|
|
302
|
+
constructor(init: ConfigurationEntryInit);
|
|
303
|
+
/* Excluded from this release type: _enqueue */
|
|
304
|
+
}
|
|
305
|
+
|
|
306
|
+
export declare type ConfigurationEntryInit = EntryInit & ({
|
|
307
|
+
target: MirisTarget;
|
|
308
|
+
data: ConfigurationMirisInit;
|
|
309
|
+
} | {
|
|
310
|
+
target: SceneTarget;
|
|
311
|
+
data: ConfigurationSceneInit;
|
|
312
|
+
} | {
|
|
313
|
+
target: ObjectTarget<"camera">;
|
|
314
|
+
data: ConfigurationCameraInit;
|
|
315
|
+
} | {
|
|
316
|
+
target: ObjectTarget<"stream">;
|
|
317
|
+
data: ConfigurationStreamInit;
|
|
318
|
+
});
|
|
319
|
+
|
|
320
|
+
export declare interface ConfigurationMirisData {
|
|
321
|
+
readonly package: string;
|
|
322
|
+
readonly version: string;
|
|
323
|
+
readonly hostname: string;
|
|
324
|
+
readonly campaignId: string;
|
|
325
|
+
readonly creativeId: string;
|
|
326
|
+
readonly placementId: string;
|
|
327
|
+
}
|
|
328
|
+
|
|
329
|
+
export declare type ConfigurationMirisInit = {
|
|
330
|
+
package: MirisPackage;
|
|
331
|
+
version: string;
|
|
332
|
+
hostname: string;
|
|
333
|
+
campaignId?: string;
|
|
334
|
+
creativeId?: string;
|
|
335
|
+
placementId?: string;
|
|
336
|
+
};
|
|
337
|
+
|
|
338
|
+
export declare interface ConfigurationSceneData {
|
|
339
|
+
readonly width: number;
|
|
340
|
+
readonly height: number;
|
|
341
|
+
readonly renderWidth: number;
|
|
342
|
+
readonly renderHeight: number;
|
|
343
|
+
readonly pixelRatio: number;
|
|
344
|
+
readonly viewerKey: string;
|
|
345
|
+
}
|
|
346
|
+
|
|
347
|
+
export declare type ConfigurationSceneInit = Omit<ConfigurationSceneData, never>;
|
|
348
|
+
|
|
349
|
+
export declare interface ConfigurationStreamData {
|
|
350
|
+
readonly assetId: string;
|
|
351
|
+
readonly boundsMin: [number, number, number];
|
|
352
|
+
readonly boundsMax: [number, number, number];
|
|
353
|
+
}
|
|
354
|
+
|
|
355
|
+
export declare type ConfigurationStreamInit = Omit<ConfigurationStreamData, never>;
|
|
356
|
+
|
|
357
|
+
export declare type ConfigValue = boolean | number | string | null | ConfigValue[] | {
|
|
358
|
+
[key: string]: ConfigValue;
|
|
359
|
+
};
|
|
360
|
+
|
|
361
|
+
declare type ConfigValues = Readonly<Record<string, ConfigValue>>;
|
|
362
|
+
|
|
145
363
|
declare interface EmbindObject {
|
|
146
364
|
delete(): void;
|
|
147
365
|
}
|
|
@@ -177,11 +395,16 @@ declare class Engine {
|
|
|
177
395
|
readonly VariantSetCollection: 7;
|
|
178
396
|
readonly VariantSet: 8;
|
|
179
397
|
readonly VariantSetOption: 9;
|
|
398
|
+
readonly ClusterLodMesh: 10;
|
|
180
399
|
};
|
|
181
400
|
static Feature: {
|
|
182
401
|
readonly DrMap: 0;
|
|
183
402
|
readonly ReflMesh: 1;
|
|
184
403
|
readonly GlassMesh: 2;
|
|
404
|
+
readonly NeuralMaterialDecoder: 3;
|
|
405
|
+
readonly DirectionalFeatureMap: 4;
|
|
406
|
+
readonly VertexLoss: 5;
|
|
407
|
+
readonly RenderAsPointCloud: 6;
|
|
185
408
|
};
|
|
186
409
|
static FeatureState: {
|
|
187
410
|
readonly NotLoaded: 0;
|
|
@@ -189,11 +412,28 @@ declare class Engine {
|
|
|
189
412
|
readonly Loaded: 2;
|
|
190
413
|
readonly Failed: 3;
|
|
191
414
|
};
|
|
415
|
+
static StreamStatus: {
|
|
416
|
+
readonly Unknown: 0;
|
|
417
|
+
readonly Resolving: 1;
|
|
418
|
+
readonly Loading: 2;
|
|
419
|
+
readonly Ready: 3;
|
|
420
|
+
readonly Failed: 4;
|
|
421
|
+
};
|
|
422
|
+
static StreamFetchMode: {
|
|
423
|
+
readonly Regular: 0;
|
|
424
|
+
readonly Prefetch: 1;
|
|
425
|
+
readonly Parked: 2;
|
|
426
|
+
};
|
|
192
427
|
readonly ready: Promise<this>;
|
|
193
428
|
readonly pending: boolean;
|
|
194
429
|
get module(): MainModule;
|
|
195
430
|
constructor(moduleOptions?: Record<string, unknown>);
|
|
196
431
|
get AttributeInfo(): new () => AttributeInfo;
|
|
432
|
+
get CompressionType(): {
|
|
433
|
+
SHARK_ELLIPSOID_COMPRESSED: unknown;
|
|
434
|
+
SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE: unknown;
|
|
435
|
+
SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE_V2: unknown;
|
|
436
|
+
};
|
|
197
437
|
get Handedness(): {
|
|
198
438
|
Right: number;
|
|
199
439
|
Left: number;
|
|
@@ -214,6 +454,7 @@ declare class Engine {
|
|
|
214
454
|
Y: number;
|
|
215
455
|
Z: number;
|
|
216
456
|
};
|
|
457
|
+
get UsePadding(): boolean;
|
|
217
458
|
activatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
218
459
|
addStreamById(...args: [
|
|
219
460
|
handle: AquaClientHandle,
|
|
@@ -224,13 +465,27 @@ declare class Engine {
|
|
|
224
465
|
allocateSceneChangesArrays(...args: [sceneChangeIds: SceneChangeIds]): void;
|
|
225
466
|
createContext(...args: []): AquaContextHandle;
|
|
226
467
|
destroyContext(...args: [handle: AquaContextHandle]): AquaStatus;
|
|
227
|
-
|
|
468
|
+
/** telemetryCollector, a collector handle or 0 for none, must outlive the client. */
|
|
469
|
+
createClient(id: number, context?: AquaContextHandle, telemetryCollector?: number): AquaClientHandle;
|
|
228
470
|
createdObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
229
471
|
deletedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
230
472
|
dataPtrView(...args: [attributeInfo: AttributeInfo]): Uint32Array;
|
|
231
473
|
deactivatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
232
474
|
remaskedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
233
475
|
getDrawnOctantMask(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
|
|
476
|
+
getOctantLocalBoundingBoxes(...args: [handle: AquaClientHandle, sceneObjectId: number]): number[];
|
|
477
|
+
getClusterLodPoolInfo(...args: [handle: AquaClientHandle, sceneObjectId: number]): ClusterLodPoolInfo | null;
|
|
478
|
+
takeClusterLodPoolWrites(...args: [handle: AquaClientHandle, sceneObjectId: number]): ClusterLodPoolWrite[] | null;
|
|
479
|
+
getClusterLodDrawList(...args: [handle: AquaClientHandle, sceneObjectId: number]): Uint32Array | null;
|
|
480
|
+
getClusterLodGlassDrawList(...args: [handle: AquaClientHandle, sceneObjectId: number]): Uint32Array | null;
|
|
481
|
+
hasClusterLodResidualPages(...args: [handle: AquaClientHandle, sceneObjectId: number]): boolean | null;
|
|
482
|
+
fetchClusterLodPageFile(...args: [
|
|
483
|
+
handle: AquaClientHandle,
|
|
484
|
+
sceneObjectId: number,
|
|
485
|
+
fileName: string,
|
|
486
|
+
fileBytes: number,
|
|
487
|
+
onComplete: ClusterLodPageFileDone
|
|
488
|
+
]): boolean;
|
|
234
489
|
destroyClient(...args: [handle: AquaClientHandle]): AquaStatus;
|
|
235
490
|
free(...args: [size: number]): number;
|
|
236
491
|
getAssetsAsync(...args: [handle: AquaClientHandle, tags: StringVector]): AssetInfo[];
|
|
@@ -249,6 +504,7 @@ declare class Engine {
|
|
|
249
504
|
getSceneChangesCounts(...args: [handle: AquaClientHandle, sceneChangeIds: SceneChangeIds]): void;
|
|
250
505
|
getSceneMetadata(...args: [handle: AquaClientHandle, metadata: SceneMetadata]): number;
|
|
251
506
|
getSceneObjectParent(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
|
|
507
|
+
getStreamStatus(...args: [handle: AquaClientHandle, streamObjectId: number]): StreamStatus;
|
|
252
508
|
getSceneObjectType(...args: [handle: AquaClientHandle, sceneObjectId: number]): SceneObjectType;
|
|
253
509
|
getLocalTransform(...args: [
|
|
254
510
|
handle: AquaClientHandle,
|
|
@@ -300,8 +556,141 @@ declare class Engine {
|
|
|
300
556
|
farPlane: number,
|
|
301
557
|
viewportHeightPixels: number
|
|
302
558
|
]): AquaStatus;
|
|
559
|
+
setStreamFetchMode(...args: [handle: AquaClientHandle, streamObjectId: number, mode: number]): boolean;
|
|
560
|
+
getStreamFetchMode(...args: [handle: AquaClientHandle, streamObjectId: number]): number;
|
|
303
561
|
setMaxCacheSize(...args: [maxSizeBytes: number]): void;
|
|
304
562
|
setPreferSharkEncodingProfiles(...args: [preferShark: boolean]): void;
|
|
563
|
+
setPadSplatAttributes(usePadding: boolean): void;
|
|
564
|
+
createTelemetryCollector(...args: [
|
|
565
|
+
sessionId: string,
|
|
566
|
+
sessionStartTimeMs: number,
|
|
567
|
+
isNewSession: boolean,
|
|
568
|
+
mirisId: number,
|
|
569
|
+
creationTimeMs: number
|
|
570
|
+
]): AquaTelemetryCollectorHandle;
|
|
571
|
+
destroyTelemetryCollector(...args: [handle: AquaTelemetryCollectorHandle]): AquaStatus;
|
|
572
|
+
tickTelemetryCollector(...args: [handle: AquaTelemetryCollectorHandle, monotonicTimeMs: number]): AquaStatus;
|
|
573
|
+
flushTelemetryCollector(...args: [handle: AquaTelemetryCollectorHandle]): AquaStatus;
|
|
574
|
+
/** Session-relative time: milliseconds since the session start, on the collector's clock. */
|
|
575
|
+
getTelemetryCollectorNow(...args: [handle: AquaTelemetryCollectorHandle]): number;
|
|
576
|
+
/** Each client reports to the collector it was created with. */
|
|
577
|
+
tickTelemetrySampler(clients: readonly AquaClientHandle[]): AquaStatus;
|
|
578
|
+
/** Reports each context's open snapshot window now, as tickTelemetrySampler would at its end. */
|
|
579
|
+
flushTelemetrySampler(clients: readonly AquaClientHandle[]): AquaStatus;
|
|
580
|
+
enqueueTelemetryConfigurationMiris(...args: [
|
|
581
|
+
handle: AquaTelemetryCollectorHandle,
|
|
582
|
+
timestampMs: number,
|
|
583
|
+
pkg: number,
|
|
584
|
+
version: string,
|
|
585
|
+
hostname: string,
|
|
586
|
+
campaignId: string,
|
|
587
|
+
creativeId: string,
|
|
588
|
+
placementId: string
|
|
589
|
+
]): AquaStatus;
|
|
590
|
+
enqueueTelemetryConfigurationScene(...args: [
|
|
591
|
+
handle: AquaTelemetryCollectorHandle,
|
|
592
|
+
timestampMs: number,
|
|
593
|
+
sceneId: number,
|
|
594
|
+
width: number,
|
|
595
|
+
height: number,
|
|
596
|
+
renderWidth: number,
|
|
597
|
+
renderHeight: number,
|
|
598
|
+
pixelRatio: number,
|
|
599
|
+
viewerKey: string
|
|
600
|
+
]): AquaStatus;
|
|
601
|
+
enqueueTelemetryConfigurationCamera(...args: [
|
|
602
|
+
handle: AquaTelemetryCollectorHandle,
|
|
603
|
+
timestampMs: number,
|
|
604
|
+
sceneId: number,
|
|
605
|
+
cameraId: number,
|
|
606
|
+
aspect: number,
|
|
607
|
+
fov: number,
|
|
608
|
+
nearPlane: number,
|
|
609
|
+
farPlane: number
|
|
610
|
+
]): AquaStatus;
|
|
611
|
+
enqueueTelemetryConfigurationStream(...args: [
|
|
612
|
+
handle: AquaTelemetryCollectorHandle,
|
|
613
|
+
timestampMs: number,
|
|
614
|
+
sceneId: number,
|
|
615
|
+
streamId: number,
|
|
616
|
+
assetId: string,
|
|
617
|
+
boundsMin: number,
|
|
618
|
+
boundsMax: number
|
|
619
|
+
]): AquaStatus;
|
|
620
|
+
enqueueTelemetryError(...args: [
|
|
621
|
+
handle: AquaTelemetryCollectorHandle,
|
|
622
|
+
timestampMs: number,
|
|
623
|
+
name: number,
|
|
624
|
+
message: string
|
|
625
|
+
]): AquaStatus;
|
|
626
|
+
enqueueTelemetryLifecycle(...args: [
|
|
627
|
+
handle: AquaTelemetryCollectorHandle,
|
|
628
|
+
timestampMs: number,
|
|
629
|
+
durationMs: number,
|
|
630
|
+
targetType: number,
|
|
631
|
+
sceneId: number,
|
|
632
|
+
objectId: number,
|
|
633
|
+
octantId: number,
|
|
634
|
+
name: number
|
|
635
|
+
]): AquaStatus;
|
|
636
|
+
enqueueTelemetryInteractionPointer(...args: [
|
|
637
|
+
handle: AquaTelemetryCollectorHandle,
|
|
638
|
+
timestampMs: number,
|
|
639
|
+
targetType: number,
|
|
640
|
+
sceneId: number,
|
|
641
|
+
objectId: number,
|
|
642
|
+
name: number,
|
|
643
|
+
x: number,
|
|
644
|
+
y: number,
|
|
645
|
+
button: number
|
|
646
|
+
]): AquaStatus;
|
|
647
|
+
enqueueTelemetryInteractionWheel(...args: [
|
|
648
|
+
handle: AquaTelemetryCollectorHandle,
|
|
649
|
+
timestampMs: number,
|
|
650
|
+
targetType: number,
|
|
651
|
+
sceneId: number,
|
|
652
|
+
objectId: number,
|
|
653
|
+
x: number,
|
|
654
|
+
y: number,
|
|
655
|
+
button: number,
|
|
656
|
+
deltaX: number,
|
|
657
|
+
deltaY: number,
|
|
658
|
+
deltaZ: number
|
|
659
|
+
]): AquaStatus;
|
|
660
|
+
enqueueTelemetrySnapshot(...args: [
|
|
661
|
+
handle: AquaTelemetryCollectorHandle,
|
|
662
|
+
timestampMs: number,
|
|
663
|
+
durationMs: number,
|
|
664
|
+
averageMainThreadTime: number,
|
|
665
|
+
averageActiveStreamCount: number,
|
|
666
|
+
averageFps: number,
|
|
667
|
+
averageVisibleNodes: number,
|
|
668
|
+
averageVisibleSplats: number,
|
|
669
|
+
averageCacheUsedBytes: number,
|
|
670
|
+
averageHeapUsedBytes: number,
|
|
671
|
+
averageHeapTotalBytes: number
|
|
672
|
+
]): AquaStatus;
|
|
673
|
+
enqueueTelemetryTiming(...args: [
|
|
674
|
+
handle: AquaTelemetryCollectorHandle,
|
|
675
|
+
timestampMs: number,
|
|
676
|
+
durationMs: number,
|
|
677
|
+
targetType: number,
|
|
678
|
+
sceneId: number,
|
|
679
|
+
objectId: number,
|
|
680
|
+
name: number
|
|
681
|
+
]): AquaStatus;
|
|
682
|
+
enqueueTelemetryTransformation(...args: [
|
|
683
|
+
handle: AquaTelemetryCollectorHandle,
|
|
684
|
+
timestampMs: number,
|
|
685
|
+
targetType: number,
|
|
686
|
+
sceneId: number,
|
|
687
|
+
objectId: number,
|
|
688
|
+
position: number,
|
|
689
|
+
quaternion: number,
|
|
690
|
+
scale: number
|
|
691
|
+
]): AquaStatus;
|
|
692
|
+
get MetricsObserver(): MetricsObserverConstructor;
|
|
693
|
+
getTelemetryHistory(collector: AquaTelemetryCollectorHandle): MetricsEntry[];
|
|
305
694
|
setSceneObjectTransform(...args: [
|
|
306
695
|
handle: AquaClientHandle,
|
|
307
696
|
sceneObjectId: number,
|
|
@@ -330,9 +719,16 @@ declare class Engine {
|
|
|
330
719
|
* displayed frame per context, before the per-client updateSceneExecution() calls.
|
|
331
720
|
* `previousFrameTimeMs` is how long the previous frame took; pass 0 when there is no plausible
|
|
332
721
|
* measurement (first frame, or a resume from a stall) and the frame advances without recording
|
|
333
|
-
*
|
|
722
|
+
* `primsResident` is what the renderer held at the end of the previous frame, fading
|
|
723
|
+
* prims included, and `primCapacity` what it can hold; activations that would not fit are
|
|
724
|
+
* deferred, where primCapacity 0 means deferral is disabled.
|
|
334
725
|
*/
|
|
335
|
-
beginFrame(...args: [
|
|
726
|
+
beginFrame(...args: [
|
|
727
|
+
contextHandle: AquaContextHandle,
|
|
728
|
+
previousFrameTimeMs: number,
|
|
729
|
+
primsResident: number,
|
|
730
|
+
primCapacity: number
|
|
731
|
+
]): AquaStatus;
|
|
336
732
|
createDeserializeWorker(_url: string, _workerUrl: string, poolSize: number): boolean;
|
|
337
733
|
cancelRequest(requestIdLow: number, requestIdHigh: number): boolean;
|
|
338
734
|
submitToWorker(requestIdLow: number, requestIdHigh: number, descriptorBuffer: ArrayBuffer, contextPtr: number): boolean;
|
|
@@ -346,6 +742,200 @@ declare type EngineMethodParameters<E extends Engine = Engine> = {
|
|
|
346
742
|
[Key in keyof E]: E[Key] extends (...args: any[]) => any ? Parameters<E[Key]> : never;
|
|
347
743
|
};
|
|
348
744
|
|
|
745
|
+
/* Excluded from this release type: EnqueueContext */
|
|
746
|
+
|
|
747
|
+
export declare abstract class Entry {
|
|
748
|
+
static [Symbol.hasInstance](value: unknown): value is MetricsEntry;
|
|
749
|
+
/* Excluded from this release type: _enqueue */
|
|
750
|
+
}
|
|
751
|
+
|
|
752
|
+
export declare type EntryInit = {
|
|
753
|
+
/**
|
|
754
|
+
* When the event happened, as session time; defaults to now. Convert other clocks with
|
|
755
|
+
* metrics.toSessionTime(): a raw performance.now() time or event.timeStamp is not session time.
|
|
756
|
+
*/
|
|
757
|
+
startTime?: SessionTime;
|
|
758
|
+
};
|
|
759
|
+
|
|
760
|
+
export declare type EntryType = MetricsEntryType;
|
|
761
|
+
|
|
762
|
+
/** The entry types a MetricsObserver can receive and Metrics keeps. */
|
|
763
|
+
export declare type EntryTypeMap = {
|
|
764
|
+
configuration: MetricsConfigurationEntry;
|
|
765
|
+
interaction: MetricsInteractionEntry;
|
|
766
|
+
lifecycle: MetricsLifecycleEntry;
|
|
767
|
+
timing: MetricsTimingEntry;
|
|
768
|
+
transformation: MetricsTransformationEntry;
|
|
769
|
+
};
|
|
770
|
+
|
|
771
|
+
declare const ERROR_NAME_ORDINAL: {
|
|
772
|
+
readonly error: 0;
|
|
773
|
+
readonly fatal: 1;
|
|
774
|
+
readonly streaming: 2;
|
|
775
|
+
readonly network: 3;
|
|
776
|
+
};
|
|
777
|
+
|
|
778
|
+
export declare class ErrorEntry extends Entry {
|
|
779
|
+
#private;
|
|
780
|
+
static [Symbol.hasInstance](value: unknown): value is MetricsErrorEntry;
|
|
781
|
+
constructor(init: ErrorEntryInit);
|
|
782
|
+
/* Excluded from this release type: _enqueue */
|
|
783
|
+
}
|
|
784
|
+
|
|
785
|
+
export declare type ErrorEntryInit = EntryInit & {
|
|
786
|
+
name: ErrorEntryName;
|
|
787
|
+
message?: string;
|
|
788
|
+
};
|
|
789
|
+
|
|
790
|
+
export declare type ErrorEntryName = keyof typeof ERROR_NAME_ORDINAL;
|
|
791
|
+
|
|
792
|
+
declare interface GlassMeshRegistry {
|
|
793
|
+
// Decodes one octree node's glass payload and registers it, replacing any previous entry for
|
|
794
|
+
// that object. False for a malformed or empty payload, leaving the registry unchanged.
|
|
795
|
+
//
|
|
796
|
+
// The two slot arguments are different numbers here, unlike on the native path, and swapping
|
|
797
|
+
// them renders glass that does not follow its asset: modelRootSlot scopes the panel dedupe to
|
|
798
|
+
// one asset instance, while chunkModelRootIndex is stamped into every vertex and read back as
|
|
799
|
+
// chunkModelRoots[pos.w], so that one takes the chunk's fade slot.
|
|
800
|
+
//
|
|
801
|
+
// geometryPtr/panelPtr address THIS module's heap - _malloc here and copy the bytes in, since
|
|
802
|
+
// the attributes live in the engine module's. The AABB is the geometry attribute's own range.
|
|
803
|
+
registerObject(
|
|
804
|
+
objectId: number,
|
|
805
|
+
lodIndex: number,
|
|
806
|
+
modelRootSlot: number,
|
|
807
|
+
chunkModelRootIndex: number,
|
|
808
|
+
geometryPtr: number,
|
|
809
|
+
geometryByteCount: number,
|
|
810
|
+
panelPtr: number,
|
|
811
|
+
panelByteCount: number,
|
|
812
|
+
aabbMinX: number,
|
|
813
|
+
aabbMinY: number,
|
|
814
|
+
aabbMinZ: number,
|
|
815
|
+
aabbMaxX: number,
|
|
816
|
+
aabbMaxY: number,
|
|
817
|
+
aabbMaxZ: number,
|
|
818
|
+
): boolean;
|
|
819
|
+
// Returns true if the object had glass, which is what says the buffers need rebuilding.
|
|
820
|
+
removeObject(objectId: number): boolean;
|
|
821
|
+
clear(): void;
|
|
822
|
+
isDirty(): boolean;
|
|
823
|
+
// Rebuilds the flattened buffers, keeping each panel from its deepest resident LOD. Stays dirty
|
|
824
|
+
// so uploadIfDirty still fires. Walks every registered object, so not per frame.
|
|
825
|
+
flattenIfDirty(): void;
|
|
826
|
+
uploadIfDirty(renderState: RenderState): void;
|
|
827
|
+
vertexCount(): number;
|
|
828
|
+
panelCount(): number;
|
|
829
|
+
delete(): void;
|
|
830
|
+
}
|
|
831
|
+
|
|
832
|
+
export declare const HaveData = 2;
|
|
833
|
+
|
|
834
|
+
export declare const HaveMetadata = 1;
|
|
835
|
+
|
|
836
|
+
export declare const HaveNothing = 0;
|
|
837
|
+
|
|
838
|
+
/** Replaces the settings of the header's kind; a header that doesn't parse keeps the current ones. */
|
|
839
|
+
export declare function ingestMirisConfig(header: string | null | undefined): void;
|
|
840
|
+
|
|
841
|
+
declare const INTERACTION_NAME_ORDINAL: {
|
|
842
|
+
readonly click: 0;
|
|
843
|
+
readonly "context-menu": 1;
|
|
844
|
+
readonly "double-click": 2;
|
|
845
|
+
readonly "pointer-down": 3;
|
|
846
|
+
readonly "pointer-enter": 4;
|
|
847
|
+
readonly "pointer-leave": 5;
|
|
848
|
+
readonly "pointer-move": 6;
|
|
849
|
+
readonly "pointer-up": 7;
|
|
850
|
+
readonly wheel: 8;
|
|
851
|
+
};
|
|
852
|
+
|
|
853
|
+
export declare interface InteractionData {
|
|
854
|
+
readonly x: number;
|
|
855
|
+
readonly y: number;
|
|
856
|
+
readonly button: number;
|
|
857
|
+
readonly deltaX?: number;
|
|
858
|
+
readonly deltaY?: number;
|
|
859
|
+
readonly deltaZ?: number;
|
|
860
|
+
}
|
|
861
|
+
|
|
862
|
+
export declare class InteractionEntry extends Entry {
|
|
863
|
+
#private;
|
|
864
|
+
static [Symbol.hasInstance](value: unknown): value is MetricsInteractionEntry;
|
|
865
|
+
constructor(init: InteractionEntryInit);
|
|
866
|
+
/* Excluded from this release type: _enqueue */
|
|
867
|
+
}
|
|
868
|
+
|
|
869
|
+
export declare type InteractionEntryInit = EntryInit & {
|
|
870
|
+
target: SceneTarget | ObjectTarget<"stream">;
|
|
871
|
+
name: InteractionEntryName;
|
|
872
|
+
data: {
|
|
873
|
+
x: number;
|
|
874
|
+
y: number;
|
|
875
|
+
button?: number;
|
|
876
|
+
deltaX?: number;
|
|
877
|
+
deltaY?: number;
|
|
878
|
+
deltaZ?: number;
|
|
879
|
+
};
|
|
880
|
+
};
|
|
881
|
+
|
|
882
|
+
export declare type InteractionEntryName = keyof typeof INTERACTION_NAME_ORDINAL;
|
|
883
|
+
|
|
884
|
+
declare const LIFECYCLE_NAME_ORDINAL: {
|
|
885
|
+
readonly create: 0;
|
|
886
|
+
readonly enable: 1;
|
|
887
|
+
readonly load: 2;
|
|
888
|
+
readonly disable: 3;
|
|
889
|
+
readonly remove: 4;
|
|
890
|
+
readonly delete: 5;
|
|
891
|
+
readonly add: 6;
|
|
892
|
+
readonly suspend: 7;
|
|
893
|
+
readonly abort: 8;
|
|
894
|
+
readonly error: 9;
|
|
895
|
+
readonly decode: 10;
|
|
896
|
+
readonly cache: 11;
|
|
897
|
+
readonly show: 12;
|
|
898
|
+
readonly hide: 13;
|
|
899
|
+
readonly evict: 14;
|
|
900
|
+
};
|
|
901
|
+
|
|
902
|
+
export declare class LifecycleEntry extends Entry {
|
|
903
|
+
#private;
|
|
904
|
+
static [Symbol.hasInstance](value: unknown): value is MetricsLifecycleEntry;
|
|
905
|
+
constructor(init: LifecycleEntryInit);
|
|
906
|
+
/* Excluded from this release type: _enqueue */
|
|
907
|
+
}
|
|
908
|
+
|
|
909
|
+
export declare type LifecycleEntryCameraName = "create" | "add" | "enable" | "disable" | "remove" | "delete";
|
|
910
|
+
|
|
911
|
+
/** A target, and one of the names it reports. */
|
|
912
|
+
export declare type LifecycleEntryInit = {
|
|
913
|
+
[K in keyof LifecycleEntryTargets]: EntryInit & {
|
|
914
|
+
target: LifecycleEntryTargets[K][0];
|
|
915
|
+
name: LifecycleEntryTargets[K][1];
|
|
916
|
+
duration?: DOMHighResTimeStamp;
|
|
917
|
+
};
|
|
918
|
+
}[keyof LifecycleEntryTargets];
|
|
919
|
+
|
|
920
|
+
/** The lifecycle names each target reports. */
|
|
921
|
+
export declare type LifecycleEntryMirisName = "create" | "enable" | "load" | "disable" | "remove" | "delete";
|
|
922
|
+
|
|
923
|
+
export declare type LifecycleEntryName = keyof typeof LIFECYCLE_NAME_ORDINAL;
|
|
924
|
+
|
|
925
|
+
/** Only Aqua reports octants. */
|
|
926
|
+
export declare type LifecycleEntryOctantName = "create" | "add" | "enable" | "load" | "abort" | "error" | "decode" | "cache" | "show" | "hide" | "evict" | "remove" | "delete";
|
|
927
|
+
|
|
928
|
+
export declare type LifecycleEntrySceneName = "create" | "add" | "enable" | "load" | "suspend" | "disable" | "remove" | "delete";
|
|
929
|
+
|
|
930
|
+
export declare type LifecycleEntryStreamName = LifecycleEntrySceneName;
|
|
931
|
+
|
|
932
|
+
declare type LifecycleEntryTargets = {
|
|
933
|
+
miris: [MirisTarget, LifecycleEntryMirisName];
|
|
934
|
+
scene: [SceneTarget, LifecycleEntrySceneName];
|
|
935
|
+
camera: [ObjectTarget<"camera">, LifecycleEntryCameraName];
|
|
936
|
+
stream: [ObjectTarget<"stream">, LifecycleEntryStreamName];
|
|
937
|
+
};
|
|
938
|
+
|
|
349
939
|
export declare class Lod {
|
|
350
940
|
#private;
|
|
351
941
|
readonly id: LodInit["id"];
|
|
@@ -376,14 +966,19 @@ export declare class Lod {
|
|
|
376
966
|
get transform(): Float32Array<ArrayBuffer> | null;
|
|
377
967
|
get _drawnOctantMask(): number;
|
|
378
968
|
set _drawnOctantMask(mask: number);
|
|
969
|
+
get _octantLocalBounds(): Float32Array<ArrayBuffer> | null;
|
|
970
|
+
set _octantLocalBounds(bounds: Float32Array<ArrayBuffer> | null);
|
|
379
971
|
get _octantOffsets(): Uint32Array<ArrayBuffer> | null;
|
|
380
972
|
get _hasOctantOffsets(): boolean;
|
|
381
973
|
get _surfelOctantOffsets(): Uint32Array<ArrayBuffer> | null;
|
|
382
974
|
get _surfelCount(): number;
|
|
975
|
+
get _surfelOwnerGroups(): Uint32Array<ArrayBuffer> | null;
|
|
976
|
+
get _octantCell(): Uint32Array<ArrayBuffer> | null;
|
|
383
977
|
_readOctantOffsets(engine: Engine): void;
|
|
384
978
|
hasAttribute(attributeName: string): boolean;
|
|
385
979
|
getDataFromAttribute(engine: Engine, attributeName: string, attributeInfo: AttributeInfo): CachedAttribute | null;
|
|
386
980
|
_getRawByteAttribute(engine: Engine, attributeName: string): Uint8Array<ArrayBuffer> | null;
|
|
981
|
+
_getRawByteAttributeWithBounds(engine: Engine, attributeName: string): RawByteAttributeWithBounds | null;
|
|
387
982
|
dispose(): void;
|
|
388
983
|
constructor({ id, modelRoot, lodStore, client }: LodInit);
|
|
389
984
|
}
|
|
@@ -406,8 +1001,13 @@ export declare class LodStore {
|
|
|
406
1001
|
deleteId(id: number): void;
|
|
407
1002
|
}
|
|
408
1003
|
|
|
409
|
-
declare interface MainModule {
|
|
1004
|
+
declare interface MainModule extends SharkModule {
|
|
410
1005
|
AttributeInfo: new () => AttributeInfo;
|
|
1006
|
+
CompressionType: {
|
|
1007
|
+
SHARK_ELLIPSOID_COMPRESSED: unknown;
|
|
1008
|
+
SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE: unknown;
|
|
1009
|
+
SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE_V2: unknown;
|
|
1010
|
+
};
|
|
411
1011
|
Handedness: { Right: number; Left: number };
|
|
412
1012
|
HEAPF32: Float32Array<ArrayBuffer>;
|
|
413
1013
|
HEAPU8: Uint8Array<ArrayBuffer>;
|
|
@@ -436,25 +1036,214 @@ declare interface MainModule {
|
|
|
436
1036
|
remaskedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
|
|
437
1037
|
deletedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
|
|
438
1038
|
GetDrawnOctantMask(handle: number, sceneObjectId: number): number;
|
|
1039
|
+
GetOctantLocalBoundingBoxes(handle: number, sceneObjectId: number): number[];
|
|
1040
|
+
GetClusterLodPoolInfo(handle: number, sceneObjectId: number): ClusterLodPoolInfo | null;
|
|
1041
|
+
TakeClusterLodPoolWrites(handle: number, sceneObjectId: number): ClusterLodPoolWrite[] | null;
|
|
1042
|
+
GetClusterLodDrawList(handle: number, sceneObjectId: number): Uint32Array | null;
|
|
1043
|
+
GetClusterLodGlassDrawList(handle: number, sceneObjectId: number): Uint32Array | null;
|
|
1044
|
+
HasClusterLodResidualPages(handle: number, sceneObjectId: number): boolean | null;
|
|
1045
|
+
FetchClusterLodPageFile(
|
|
1046
|
+
handle: number,
|
|
1047
|
+
sceneObjectId: number,
|
|
1048
|
+
fileName: string,
|
|
1049
|
+
fileBytes: number,
|
|
1050
|
+
onComplete: ClusterLodPageFileDone,
|
|
1051
|
+
): boolean;
|
|
439
1052
|
GetAssetsAsync(handle: number, tags: StringVector): unknown[];
|
|
440
1053
|
GetSceneChanges(handle: number, sceneChangeIds: SceneChangeIds): void;
|
|
441
1054
|
GetSceneChangesCounts(handle: number, sceneChangeIds: SceneChangeIds): void;
|
|
442
1055
|
GetSceneMetadata(handle: number, metadata: SceneMetadata): { value: number };
|
|
443
1056
|
GetName(handle: number, sceneObjectId: number): string;
|
|
444
1057
|
HasFeature(handle: number, sceneObjectId: number, feature: number): boolean;
|
|
445
|
-
GetFeatureVersion(
|
|
446
|
-
|
|
1058
|
+
GetFeatureVersion(
|
|
1059
|
+
handle: number,
|
|
1060
|
+
sceneObjectId: number,
|
|
1061
|
+
feature: number,
|
|
1062
|
+
): number;
|
|
1063
|
+
GetFeatureState(
|
|
1064
|
+
handle: number,
|
|
1065
|
+
sceneObjectId: number,
|
|
1066
|
+
feature: number,
|
|
1067
|
+
): number;
|
|
447
1068
|
GetAssetFormatVersion(handle: number, sceneObjectId: number): number;
|
|
448
|
-
GetDrMapLadderRoughnessLevels(
|
|
449
|
-
|
|
450
|
-
|
|
1069
|
+
GetDrMapLadderRoughnessLevels(
|
|
1070
|
+
handle: number,
|
|
1071
|
+
sceneObjectId: number,
|
|
1072
|
+
): number[];
|
|
1073
|
+
SetClientSpatialFormat(
|
|
1074
|
+
handle: number,
|
|
1075
|
+
spatialFormat: SpatialFormat,
|
|
1076
|
+
): { value: number };
|
|
1077
|
+
SetRuntimeSettings(
|
|
1078
|
+
handle: number,
|
|
1079
|
+
settings: RuntimeSettings,
|
|
1080
|
+
): { value: number };
|
|
1081
|
+
SetStreamFetchMode(
|
|
1082
|
+
handle: number,
|
|
1083
|
+
streamObjectId: number,
|
|
1084
|
+
mode: number,
|
|
1085
|
+
): boolean;
|
|
1086
|
+
GetStreamFetchMode(handle: number, streamObjectId: number): number;
|
|
451
1087
|
TakeEvictedClientSideAttributeIds(handle: number): EmbindVector<bigint>;
|
|
452
1088
|
GetActiveClientSideIdsCheckSum(): number;
|
|
453
1089
|
TakeRenderRequired(handle: number): boolean;
|
|
454
|
-
BeginFrame(
|
|
1090
|
+
BeginFrame(
|
|
1091
|
+
contextHandle: number,
|
|
1092
|
+
previousFrameTimeMs: number,
|
|
1093
|
+
primsResident: number,
|
|
1094
|
+
primCapacity: number,
|
|
1095
|
+
): number;
|
|
455
1096
|
modifiedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
|
|
456
1097
|
setMaxCacheSize(maxSizeBytes: number): void;
|
|
457
1098
|
SetPreferSharkEncodingProfiles(prefer: boolean): void;
|
|
1099
|
+
SetLossHeatmapEnabled(handle: number, enabled: boolean): void;
|
|
1100
|
+
|
|
1101
|
+
MetricsObserver: MetricsObserverConstructor;
|
|
1102
|
+
getTelemetryHistory(collectorHandle: number): MetricsEntry[];
|
|
1103
|
+
}
|
|
1104
|
+
|
|
1105
|
+
export declare class Metrics {
|
|
1106
|
+
#private;
|
|
1107
|
+
constructor(engine: Engine, collector: AquaTelemetryCollectorHandle, sessionStartTimeMs: number);
|
|
1108
|
+
get timeOrigin(): DOMHighResTimeStamp;
|
|
1109
|
+
/** Session time now: milliseconds since the session start, on the collector's clock. */
|
|
1110
|
+
now(): SessionTime;
|
|
1111
|
+
/** Converts a performance.now() time, or an Event's timeStamp, to session time. */
|
|
1112
|
+
toSessionTime(time: DOMHighResTimeStamp | Event): SessionTime;
|
|
1113
|
+
queue<E extends Entry>(entry: E): E;
|
|
1114
|
+
/** Every public entry Aqua still remembers, oldest first; none once detached. */
|
|
1115
|
+
getEntries(): MetricsEntry[];
|
|
1116
|
+
getEntriesByName(name: string, type?: string): MetricsEntry[];
|
|
1117
|
+
getEntriesByType<K extends keyof EntryTypeMap>(type: K): EntryTypeMap[K][];
|
|
1118
|
+
getEntriesByType(type: string): MetricsEntry[];
|
|
1119
|
+
/* Excluded from this release type: _detach */
|
|
1120
|
+
}
|
|
1121
|
+
|
|
1122
|
+
export declare interface MetricsConfigurationEntry extends MetricsEntry {
|
|
1123
|
+
readonly type: "configuration";
|
|
1124
|
+
readonly data:
|
|
1125
|
+
| ConfigurationMirisData
|
|
1126
|
+
| ConfigurationSceneData
|
|
1127
|
+
| ConfigurationCameraData
|
|
1128
|
+
| ConfigurationStreamData;
|
|
1129
|
+
}
|
|
1130
|
+
|
|
1131
|
+
export declare interface MetricsEntry {
|
|
1132
|
+
readonly entryId: number;
|
|
1133
|
+
readonly name: string;
|
|
1134
|
+
readonly type: MetricsEntryType;
|
|
1135
|
+
readonly platform: string;
|
|
1136
|
+
/** ms since the session start. */
|
|
1137
|
+
readonly startTime: number;
|
|
1138
|
+
readonly duration: number;
|
|
1139
|
+
/** "<miris>-<scene>[-<camera|stream>[-<octree>.<node>]]"; empty for the session target. */
|
|
1140
|
+
readonly targetId: string;
|
|
1141
|
+
readonly targetType: MetricsTargetType;
|
|
1142
|
+
readonly sessionId: string;
|
|
1143
|
+
}
|
|
1144
|
+
|
|
1145
|
+
declare type MetricsEntryType =
|
|
1146
|
+
| "configuration"
|
|
1147
|
+
| "error"
|
|
1148
|
+
| "interaction"
|
|
1149
|
+
| "lifecycle"
|
|
1150
|
+
| "session"
|
|
1151
|
+
| "snapshot"
|
|
1152
|
+
| "timing"
|
|
1153
|
+
| "transformation";
|
|
1154
|
+
|
|
1155
|
+
export declare interface MetricsErrorEntry extends MetricsEntry {
|
|
1156
|
+
readonly type: "error";
|
|
1157
|
+
readonly message: string;
|
|
1158
|
+
}
|
|
1159
|
+
|
|
1160
|
+
export declare interface MetricsInteractionEntry extends MetricsEntry {
|
|
1161
|
+
readonly type: "interaction";
|
|
1162
|
+
readonly data: InteractionData;
|
|
1163
|
+
}
|
|
1164
|
+
|
|
1165
|
+
export declare interface MetricsLifecycleEntry extends MetricsEntry {
|
|
1166
|
+
readonly type: "lifecycle";
|
|
1167
|
+
}
|
|
1168
|
+
|
|
1169
|
+
export declare class MetricsObserver {
|
|
1170
|
+
#private;
|
|
1171
|
+
static get supportedEntryTypes(): EntryType[];
|
|
1172
|
+
constructor(callback: MetricsObserverCallback, options?: MetricsObserverOptions);
|
|
1173
|
+
observe(options?: MetricsObserverInit): void;
|
|
1174
|
+
disconnect(): void;
|
|
1175
|
+
takeRecords(): MetricsEntry[];
|
|
1176
|
+
}
|
|
1177
|
+
|
|
1178
|
+
declare interface MetricsObserver_2 extends EmbindObject {
|
|
1179
|
+
observe(options?: MetricsObserverInit_2): void;
|
|
1180
|
+
disconnect(): void;
|
|
1181
|
+
takeRecords(): MetricsEntry[];
|
|
1182
|
+
}
|
|
1183
|
+
|
|
1184
|
+
export declare type MetricsObserverCallback = (entries: MetricsObserverEntryList, observer: MetricsObserver) => void;
|
|
1185
|
+
|
|
1186
|
+
declare type MetricsObserverCallback_2 = (
|
|
1187
|
+
entries: MetricsEntry[],
|
|
1188
|
+
observer: undefined,
|
|
1189
|
+
) => void;
|
|
1190
|
+
|
|
1191
|
+
declare interface MetricsObserverConstructor {
|
|
1192
|
+
new (
|
|
1193
|
+
collectorHandle: number,
|
|
1194
|
+
callback: MetricsObserverCallback_2,
|
|
1195
|
+
options: MetricsObserverConstructorOptions,
|
|
1196
|
+
): MetricsObserver_2;
|
|
1197
|
+
/** The public entry types, the only ones a MetricsObserver can receive. */
|
|
1198
|
+
supportedEntryTypes(): MetricsEntryType[];
|
|
1199
|
+
}
|
|
1200
|
+
|
|
1201
|
+
declare interface MetricsObserverConstructorOptions {
|
|
1202
|
+
flushInterval?: number;
|
|
1203
|
+
}
|
|
1204
|
+
|
|
1205
|
+
export declare class MetricsObserverEntryList {
|
|
1206
|
+
#private;
|
|
1207
|
+
constructor(entries: MetricsEntry[]);
|
|
1208
|
+
getEntries(): MetricsEntry[];
|
|
1209
|
+
getEntriesByName(name: string, type?: string): MetricsEntry[];
|
|
1210
|
+
getEntriesByType(type: string): MetricsEntry[];
|
|
1211
|
+
}
|
|
1212
|
+
|
|
1213
|
+
export declare type MetricsObserverInit = {
|
|
1214
|
+
buffered?: boolean;
|
|
1215
|
+
entryTypes?: string[];
|
|
1216
|
+
type?: string;
|
|
1217
|
+
};
|
|
1218
|
+
|
|
1219
|
+
declare interface MetricsObserverInit_2 {
|
|
1220
|
+
entryTypes?: string[];
|
|
1221
|
+
type?: string;
|
|
1222
|
+
buffered?: boolean;
|
|
1223
|
+
}
|
|
1224
|
+
|
|
1225
|
+
export declare type MetricsObserverOptions = {
|
|
1226
|
+
/** Seconds between flushes to the callback; 0 flushes only on overflow. Default 30. */
|
|
1227
|
+
flushInterval?: number;
|
|
1228
|
+
};
|
|
1229
|
+
|
|
1230
|
+
export declare interface MetricsSnapshotEntry extends MetricsEntry {
|
|
1231
|
+
readonly type: "snapshot";
|
|
1232
|
+
readonly data: SnapshotData;
|
|
1233
|
+
}
|
|
1234
|
+
|
|
1235
|
+
declare type MetricsTargetType =
|
|
1236
|
+
"miris" | "scene" | "camera" | "stream" | "octant" | "session";
|
|
1237
|
+
|
|
1238
|
+
export declare interface MetricsTimingEntry extends MetricsEntry {
|
|
1239
|
+
readonly type: "timing";
|
|
1240
|
+
}
|
|
1241
|
+
|
|
1242
|
+
export declare interface MetricsTransformationEntry extends MetricsEntry {
|
|
1243
|
+
readonly type: "transformation";
|
|
1244
|
+
readonly position: [number, number, number];
|
|
1245
|
+
readonly quaternion: [number, number, number, number];
|
|
1246
|
+
readonly scale: [number, number, number];
|
|
458
1247
|
}
|
|
459
1248
|
|
|
460
1249
|
/**
|
|
@@ -469,14 +1258,23 @@ export declare class Miris {
|
|
|
469
1258
|
#private;
|
|
470
1259
|
static tryUseShark: boolean;
|
|
471
1260
|
static _instance: Miris;
|
|
1261
|
+
/** The package this Miris reports in configuration/miris. */
|
|
1262
|
+
static readonly package: MirisPackage;
|
|
472
1263
|
static instance<T extends typeof Miris>(this: T): Promise<InstanceType<T>>;
|
|
473
1264
|
readonly engine: Engine;
|
|
474
1265
|
readonly ready: Promise<this>;
|
|
475
1266
|
readonly pending: boolean;
|
|
1267
|
+
/** Unique within the telemetry session; defined once `ready` resolves, if it joined one. */
|
|
1268
|
+
readonly id: number;
|
|
476
1269
|
get sharedContext(): number | undefined;
|
|
1270
|
+
get telemetryCollector(): number | undefined;
|
|
1271
|
+
get metrics(): Metrics;
|
|
477
1272
|
get viewerKey(): string | null | undefined;
|
|
478
1273
|
set viewerKey(viewerKey: string | null | undefined);
|
|
479
1274
|
get scenes(): Set<Scene>;
|
|
1275
|
+
/* Excluded from this release type: _trackLiveScene */
|
|
1276
|
+
/* Excluded from this release type: _untrackLiveScene */
|
|
1277
|
+
/* Excluded from this release type: _createNewClientId */
|
|
480
1278
|
get useSphericalHarmonics(): boolean;
|
|
481
1279
|
set useSphericalHarmonics(value: boolean);
|
|
482
1280
|
constructor();
|
|
@@ -486,6 +1284,7 @@ export declare class Miris {
|
|
|
486
1284
|
protected _xrSession: XRSession | null;
|
|
487
1285
|
protected _requestAnimationFrame: RequestAnimationFrameFn | null;
|
|
488
1286
|
signalResumeFromIdle(): void;
|
|
1287
|
+
/* Excluded from this release type: _enableClusterLod */
|
|
489
1288
|
get _splatCountBudget(): number;
|
|
490
1289
|
/**
|
|
491
1290
|
* Why 43? Because the AVP throttles down to 45Hz :(
|
|
@@ -493,15 +1292,21 @@ export declare class Miris {
|
|
|
493
1292
|
static readonly _XR_TARGET_FRAME_RATE = 43;
|
|
494
1293
|
/* Excluded from this release type: _XR_SPLAT_COUNT_BUDGET */
|
|
495
1294
|
/* Excluded from this release type: _SHARK_SPLAT_CAPACITY_MOBILE */
|
|
496
|
-
static readonly _SHARK_SPLAT_CAPACITY_DESKTOP
|
|
1295
|
+
static readonly _SHARK_SPLAT_CAPACITY_DESKTOP: number;
|
|
497
1296
|
/* Excluded from this release type: _SHARK_SPLAT_BUDGET_CAP_MOBILE */
|
|
498
|
-
static readonly _SHARK_SPLAT_BUDGET_CAP_DESKTOP =
|
|
1297
|
+
static readonly _SHARK_SPLAT_BUDGET_CAP_DESKTOP = 2400000;
|
|
1298
|
+
/* Excluded from this release type: _CLUSTER_LOD_POOL_BYTES_MOBILE */
|
|
499
1299
|
/* Excluded from this release type: _isMobileDevice */
|
|
500
1300
|
/* Excluded from this release type: _sharkSplatCapacity */
|
|
1301
|
+
/* Excluded from this release type: _minimumSplatCount */
|
|
1302
|
+
/* Excluded from this release type: _splatCountStorageKey */
|
|
1303
|
+
/* Excluded from this release type: _reloadWithLowerSplatCapacity */
|
|
1304
|
+
/* Excluded from this release type: _limitSharkSplatCapacity */
|
|
501
1305
|
/* Excluded from this release type: _sharkSplatBudgetCap */
|
|
502
1306
|
/* Excluded from this release type: _setTargetFrameRate */
|
|
503
1307
|
/* Excluded from this release type: _setXRModeActive */
|
|
504
1308
|
/* Excluded from this release type: _setSplatCountBudgetOverride */
|
|
1309
|
+
/* Excluded from this release type: _reportRendererPrims */
|
|
505
1310
|
/* Excluded from this release type: _update */
|
|
506
1311
|
getLocalTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
|
|
507
1312
|
getWorldTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
|
|
@@ -513,10 +1318,16 @@ export declare class Miris {
|
|
|
513
1318
|
delete(scene: Scene): void;
|
|
514
1319
|
}
|
|
515
1320
|
|
|
1321
|
+
export declare type MirisPackage = keyof typeof PACKAGE_ORDINAL;
|
|
1322
|
+
|
|
1323
|
+
/** What an entry is about: `id`s are Scene, Camera and Stream ids. */
|
|
1324
|
+
export declare type MirisTarget = {
|
|
1325
|
+
readonly type: "miris";
|
|
1326
|
+
};
|
|
1327
|
+
|
|
516
1328
|
export declare class ModelRoot {
|
|
517
1329
|
#private;
|
|
518
1330
|
static forKey(key: unknown): ModelRoot | undefined;
|
|
519
|
-
static forId(id: number): ModelRoot | undefined;
|
|
520
1331
|
readonly id: ModelRootInit["id"];
|
|
521
1332
|
get key(): unknown;
|
|
522
1333
|
set key(key: unknown);
|
|
@@ -534,6 +1345,141 @@ export declare type ModelRootInit = {
|
|
|
534
1345
|
stream: Stream;
|
|
535
1346
|
};
|
|
536
1347
|
|
|
1348
|
+
export declare type ObjectTarget<Type extends "camera" | "stream" = "camera" | "stream"> = {
|
|
1349
|
+
readonly type: Type;
|
|
1350
|
+
readonly id: number;
|
|
1351
|
+
readonly scene: {
|
|
1352
|
+
readonly id: number;
|
|
1353
|
+
};
|
|
1354
|
+
};
|
|
1355
|
+
|
|
1356
|
+
declare const PACKAGE_ORDINAL: {
|
|
1357
|
+
readonly "@miris-inc/core": 0;
|
|
1358
|
+
readonly "@miris-inc/components": 1;
|
|
1359
|
+
readonly "@miris-inc/three": 2;
|
|
1360
|
+
};
|
|
1361
|
+
|
|
1362
|
+
/**
|
|
1363
|
+
* The byte-exact counterpart of getRawUint32Attribute above: same no-padding, no-takeAttribute
|
|
1364
|
+
* contract, returning bytes rather than words.
|
|
1365
|
+
*
|
|
1366
|
+
* Use this rather than that one wherever the stride is not a whole number of words: the
|
|
1367
|
+
* reflectance records' 18- and 26-byte strides are not, and an odd record count would lose that
|
|
1368
|
+
* record's last field to dataPtrView's truncation.
|
|
1369
|
+
*/
|
|
1370
|
+
export declare type RawByteAttributeWithBounds = {
|
|
1371
|
+
bytes: Uint8Array<ArrayBuffer>;
|
|
1372
|
+
minValue: {
|
|
1373
|
+
x: number;
|
|
1374
|
+
y: number;
|
|
1375
|
+
z: number;
|
|
1376
|
+
};
|
|
1377
|
+
maxValue: {
|
|
1378
|
+
x: number;
|
|
1379
|
+
y: number;
|
|
1380
|
+
z: number;
|
|
1381
|
+
};
|
|
1382
|
+
};
|
|
1383
|
+
|
|
1384
|
+
declare type ReadyState_2 = typeof HaveNothing | typeof HaveMetadata | typeof HaveData;
|
|
1385
|
+
export { ReadyState_2 as ReadyState }
|
|
1386
|
+
|
|
1387
|
+
export declare class RemoteConfig {
|
|
1388
|
+
#private;
|
|
1389
|
+
readonly kind: string;
|
|
1390
|
+
constructor(kind: string);
|
|
1391
|
+
/** The header the current values came from, for persisting and later ingesting. */
|
|
1392
|
+
get raw(): string | undefined;
|
|
1393
|
+
values(): ConfigValues;
|
|
1394
|
+
get(key: string): ConfigValue | undefined;
|
|
1395
|
+
bool(key: string, fallback: boolean): boolean;
|
|
1396
|
+
number(key: string, fallback: number): number;
|
|
1397
|
+
int(key: string, fallback: number): number;
|
|
1398
|
+
string(key: string, fallback: string): string;
|
|
1399
|
+
/** A JSON setting, given as an object or as a JSON string; fallback unless isT accepts it. */
|
|
1400
|
+
json<T>(key: string, fallback: T, isT: (value: unknown) => value is T): T;
|
|
1401
|
+
/** Calls listener after each change of values; returns the unsubscribe. */
|
|
1402
|
+
subscribe(listener: () => void): () => void;
|
|
1403
|
+
/* Excluded from this release type: set */
|
|
1404
|
+
}
|
|
1405
|
+
|
|
1406
|
+
/** The settings of kind, such as "client" or "sdk"; empty until a header for it is ingested. */
|
|
1407
|
+
export declare function remoteConfig(kind: string): RemoteConfig;
|
|
1408
|
+
|
|
1409
|
+
declare interface RendererWGPU {
|
|
1410
|
+
getProgramCount(): number;
|
|
1411
|
+
getTextureCount(): number;
|
|
1412
|
+
getEstimatedTextureSize(): number;
|
|
1413
|
+
getTotalBufferSize(): number;
|
|
1414
|
+
getGpuBufferSize(): number;
|
|
1415
|
+
getUploadBufferSize(): number;
|
|
1416
|
+
info: SharkInfo;
|
|
1417
|
+
delete(): void;
|
|
1418
|
+
}
|
|
1419
|
+
|
|
1420
|
+
declare interface RenderState {
|
|
1421
|
+
delete(): void;
|
|
1422
|
+
initRenderState(
|
|
1423
|
+
renderer: RendererWGPU,
|
|
1424
|
+
width: number,
|
|
1425
|
+
height: number,
|
|
1426
|
+
vertices: number,
|
|
1427
|
+
splats: number,
|
|
1428
|
+
cubes: number,
|
|
1429
|
+
sortThreads: number,
|
|
1430
|
+
sortGroupSize: number,
|
|
1431
|
+
sortKeySize: number,
|
|
1432
|
+
): void;
|
|
1433
|
+
initGraphicsState(
|
|
1434
|
+
width: number,
|
|
1435
|
+
height: number,
|
|
1436
|
+
renderTextureFormat: TextureFormatValue,
|
|
1437
|
+
depthTextureFormat: TextureFormatValue,
|
|
1438
|
+
): void;
|
|
1439
|
+
updateRenderDetails(
|
|
1440
|
+
width: number,
|
|
1441
|
+
height: number,
|
|
1442
|
+
splatTriangles: number,
|
|
1443
|
+
): void;
|
|
1444
|
+
// Decodes Radiance .hdr bytes into roughness-ladder level `level` (0 is the sharp mirror).
|
|
1445
|
+
// hdrPtr must address THIS module's heap - _malloc here and copy the bytes in.
|
|
1446
|
+
// Returns false for bytes that are not a usable Radiance image, or a level out of range.
|
|
1447
|
+
uploadEnvironmentLadderLevelFromHdr(
|
|
1448
|
+
level: number,
|
|
1449
|
+
sigmaDeg: number,
|
|
1450
|
+
hdrPtr: number,
|
|
1451
|
+
hdrSizeBytes: number,
|
|
1452
|
+
): boolean;
|
|
1453
|
+
// Republish the ladder's shape. Call after any level lands, or it is sampled at whatever shape
|
|
1454
|
+
// the last uploadSplatSetData declared. Pass SplatSet.hasReflectionParams().
|
|
1455
|
+
uploadReflectionLadderParams(reflectionsEnabled: boolean): void;
|
|
1456
|
+
// Debug controls. Drop the reflection term, or replace the surfel colour with one of the layers
|
|
1457
|
+
// it is shaded from, numbered as RenderViewModes.h's AOV_* defines. setRenderView below sets
|
|
1458
|
+
// the AOV together with the rest of a named view.
|
|
1459
|
+
setReflectionsEnabled(enabled: boolean): void;
|
|
1460
|
+
// Render textured gaussians on pixels no surfel covers, resolved as fvdb's open gate does.
|
|
1461
|
+
// Off by default: those pixels show the clear colour.
|
|
1462
|
+
setSurfelLessTextureSplatsEnabled(enabled: boolean): void;
|
|
1463
|
+
setDebugAovMode(mode: number): void;
|
|
1464
|
+
// chunkModelRootIndex is a fade slot of one of the trained mesh's chunks.
|
|
1465
|
+
setTrainedMeshMode(active: boolean, chunkModelRootIndex: number): void;
|
|
1466
|
+
// A Mesh View, indexed as trainedMeshViewName orders them, and the gain on its signed channel views.
|
|
1467
|
+
setTrainedMeshView(view: number, scale: number): void;
|
|
1468
|
+
// Enabled, draws only the trained mesh stream piece with this id.
|
|
1469
|
+
setTrainedMeshFilter(enabled: boolean, pieceId: number): void;
|
|
1470
|
+
isTrainedMeshLoaded(): boolean;
|
|
1471
|
+
hasClusterLodPool(): boolean;
|
|
1472
|
+
setResidualEnabled(enabled: boolean): void;
|
|
1473
|
+
// The largest buffer the device binds as storage, in bytes: AquaApi's clusterLodMaxBufferBytes.
|
|
1474
|
+
largestStorageBufferBytes(): number;
|
|
1475
|
+
// GPU pass timing. Turning it on makes every pass write timestamps; a no-op on a device without
|
|
1476
|
+
// timestamp-query. resolveTimeStamps goes after a frame's render; passTimingsMs starts a readback
|
|
1477
|
+
// of them unless one is in flight and maps pass name to milliseconds from the last that landed.
|
|
1478
|
+
setPassTimingEnabled(enabled: boolean): void;
|
|
1479
|
+
resolveTimeStamps(): void;
|
|
1480
|
+
passTimingsMs(): Record<string, number>;
|
|
1481
|
+
}
|
|
1482
|
+
|
|
537
1483
|
declare type RequestAnimationFrameFn = ((callback: FrameRequestCallback) => number) | ((callback: XRFrameRequestCallback) => void);
|
|
538
1484
|
|
|
539
1485
|
declare interface RuntimeSettings extends EmbindObject {
|
|
@@ -543,6 +1489,10 @@ declare interface RuntimeSettings extends EmbindObject {
|
|
|
543
1489
|
xrModeActive: boolean;
|
|
544
1490
|
splatCountBudget: number;
|
|
545
1491
|
splatCountBudgetCap: number;
|
|
1492
|
+
// 0 for the platform's default.
|
|
1493
|
+
clusterLodPoolBudgetBytes: number;
|
|
1494
|
+
// The renderer's largest storage buffer; 0 for no limit.
|
|
1495
|
+
clusterLodMaxBufferBytes: number;
|
|
546
1496
|
}
|
|
547
1497
|
|
|
548
1498
|
export declare class Scene extends EventTarget {
|
|
@@ -559,6 +1509,9 @@ export declare class Scene extends EventTarget {
|
|
|
559
1509
|
set viewerKey(viewerKey: string | null);
|
|
560
1510
|
get streams(): Set<Stream>;
|
|
561
1511
|
get lods(): LodStore;
|
|
1512
|
+
/* Excluded from this release type: _addClusterLodMesh */
|
|
1513
|
+
/* Excluded from this release type: _deleteClusterLodMesh */
|
|
1514
|
+
/* Excluded from this release type: _updateClusterLodMeshes */
|
|
562
1515
|
readonly miris: Miris;
|
|
563
1516
|
readonly engine: Engine;
|
|
564
1517
|
readonly client: Client;
|
|
@@ -586,13 +1539,19 @@ export declare class Scene extends EventTarget {
|
|
|
586
1539
|
add(stream: Stream): void;
|
|
587
1540
|
getStreamForId(streamObjectId: number): Stream | undefined;
|
|
588
1541
|
getStreamForDescendentId(descendentObjectId: number): Stream | null;
|
|
1542
|
+
/** This scene's model root with the id, which another scene's client may also use. */
|
|
1543
|
+
getModelRootForId(modelRootId: number): ModelRoot | null;
|
|
589
1544
|
getModelRootForDescendentId(descendentObjectId: number): ModelRoot | null;
|
|
590
1545
|
_recordAssetFormat(modelRoot: ModelRoot, formatVersion: number): void;
|
|
591
1546
|
/* Excluded from this release type: _getFeatureMesh */
|
|
1547
|
+
/* Excluded from this release type: _takeAttributeBuffer */
|
|
592
1548
|
/* Excluded from this release type: _getDrMap */
|
|
593
1549
|
/* Excluded from this release type: _onDrMapLadder */
|
|
594
1550
|
/* Excluded from this release type: _onFeatureData */
|
|
1551
|
+
/* Excluded from this release type: _applyStreamFetchModes */
|
|
1552
|
+
/* Excluded from this release type: _updateStreamStatuses */
|
|
595
1553
|
/* Excluded from this release type: _onSceneLoaded */
|
|
1554
|
+
/* Excluded from this release type: _releaseStreamId */
|
|
596
1555
|
delete(stream: Stream): void;
|
|
597
1556
|
close(): void;
|
|
598
1557
|
}
|
|
@@ -615,12 +1574,165 @@ declare interface SceneMetadata extends EmbindObject {
|
|
|
615
1574
|
readonly inputColorSpace: string;
|
|
616
1575
|
}
|
|
617
1576
|
|
|
618
|
-
declare type
|
|
619
|
-
|
|
620
|
-
|
|
1577
|
+
export declare type SceneTarget = {
|
|
1578
|
+
readonly type: "scene";
|
|
1579
|
+
readonly id: number;
|
|
621
1580
|
};
|
|
622
1581
|
|
|
623
|
-
|
|
1582
|
+
/**
|
|
1583
|
+
* Milliseconds since the session start, the timeline every entry's startTime is on. Only Metrics
|
|
1584
|
+
* makes one: metrics.now(), or metrics.toSessionTime() for a performance.now() time or an Event.
|
|
1585
|
+
*/
|
|
1586
|
+
export declare type SessionTime = number & {
|
|
1587
|
+
readonly [sessionTimeBrand]: true;
|
|
1588
|
+
};
|
|
1589
|
+
|
|
1590
|
+
declare const sessionTimeBrand: unique symbol;
|
|
1591
|
+
|
|
1592
|
+
declare interface SharkInfo {
|
|
1593
|
+
renderCalls: number;
|
|
1594
|
+
render: SharkRenderInfo;
|
|
1595
|
+
reset(): void;
|
|
1596
|
+
}
|
|
1597
|
+
|
|
1598
|
+
declare interface SharkModule {
|
|
1599
|
+
Camera: new () => Camera_2;
|
|
1600
|
+
ClusterLodDrawState: new () => ClusterLodDrawState;
|
|
1601
|
+
ClusterLodResidualPages: new (
|
|
1602
|
+
fetch: ClusterLodResidualPageFetch,
|
|
1603
|
+
) => ClusterLodResidualPages;
|
|
1604
|
+
RenderState: new () => RenderState;
|
|
1605
|
+
SplatSet: new () => SplatSet;
|
|
1606
|
+
GlassMeshRegistry: new () => GlassMeshRegistry;
|
|
1607
|
+
TrainedMeshStreamRegistry: new () => TrainedMeshStreamRegistry;
|
|
1608
|
+
vec4: new (x: number, y: number, z: number, w: number) => vec4;
|
|
1609
|
+
|
|
1610
|
+
SortType: {
|
|
1611
|
+
RADIX_SORT: SortTypeValue;
|
|
1612
|
+
OCTREE_SORT: SortTypeValue;
|
|
1613
|
+
KDTREE_SORT: SortTypeValue;
|
|
1614
|
+
STD_SORT: SortTypeValue;
|
|
1615
|
+
};
|
|
1616
|
+
|
|
1617
|
+
TextureFormat: {
|
|
1618
|
+
RGBA32_Float: TextureFormatValue;
|
|
1619
|
+
RGBA16_Float: TextureFormatValue;
|
|
1620
|
+
RG16_Float: TextureFormatValue;
|
|
1621
|
+
RGBA32_UInt: TextureFormatValue;
|
|
1622
|
+
RGBA32_SInt: TextureFormatValue;
|
|
1623
|
+
RGBA16_UInt: TextureFormatValue;
|
|
1624
|
+
RGBA16_SInt: TextureFormatValue;
|
|
1625
|
+
RGBA8_UInt: TextureFormatValue;
|
|
1626
|
+
RGBA8_SInt: TextureFormatValue;
|
|
1627
|
+
RGBA8_UNorm: TextureFormatValue;
|
|
1628
|
+
RGBA8_SNorm: TextureFormatValue;
|
|
1629
|
+
RGBA16_UNorm: TextureFormatValue;
|
|
1630
|
+
RGBA16_SNorm: TextureFormatValue;
|
|
1631
|
+
BGRA8_UNorm: TextureFormatValue;
|
|
1632
|
+
BC6HRGB_UFloat: TextureFormatValue;
|
|
1633
|
+
BC6HRGB_Float: TextureFormatValue;
|
|
1634
|
+
BC7RGBA_UNorm: TextureFormatValue;
|
|
1635
|
+
BC7RGBA_UNormSrgb: TextureFormatValue;
|
|
1636
|
+
BC3RGBA_UNorm: TextureFormatValue;
|
|
1637
|
+
BC3RGBA_UNormSrgb: TextureFormatValue;
|
|
1638
|
+
Depth16Unorm: TextureFormatValue;
|
|
1639
|
+
Depth24Plus: TextureFormatValue;
|
|
1640
|
+
Depth32Float: TextureFormatValue;
|
|
1641
|
+
};
|
|
1642
|
+
|
|
1643
|
+
WebGPU: WebGPUInterface;
|
|
1644
|
+
|
|
1645
|
+
// HEAPU8 is replaced whenever the heap grows, so read it fresh rather than caching it.
|
|
1646
|
+
_malloc(byteCount: number): number;
|
|
1647
|
+
_free(ptr: number): void;
|
|
1648
|
+
readonly HEAPU8: Uint8Array;
|
|
1649
|
+
|
|
1650
|
+
uploadSplatSetData(
|
|
1651
|
+
set: SplatSet,
|
|
1652
|
+
renderState: RenderState,
|
|
1653
|
+
start: number,
|
|
1654
|
+
): void;
|
|
1655
|
+
uploadChunkFades(set: SplatSet, renderState: RenderState): void;
|
|
1656
|
+
// One mat4 per model root, so cheap enough to call every frame while an asset is moving
|
|
1657
|
+
uploadModelRootTransforms(set: SplatSet, renderState: RenderState): void;
|
|
1658
|
+
processSplatSet(
|
|
1659
|
+
camera: Camera_2,
|
|
1660
|
+
set: SplatSet,
|
|
1661
|
+
renderState: RenderState,
|
|
1662
|
+
width: number,
|
|
1663
|
+
height: number,
|
|
1664
|
+
triangles: number,
|
|
1665
|
+
projectOnGPU: boolean,
|
|
1666
|
+
cullEllipsoid: boolean,
|
|
1667
|
+
useAffineApprox: boolean,
|
|
1668
|
+
depthSortOnGPU: boolean,
|
|
1669
|
+
useInvZ: boolean,
|
|
1670
|
+
rasterizeWithCompute: boolean,
|
|
1671
|
+
useSOGS: boolean,
|
|
1672
|
+
sortType: SortTypeValue,
|
|
1673
|
+
skipSort: boolean,
|
|
1674
|
+
): number;
|
|
1675
|
+
createRendererWGPUWithoutSurface(
|
|
1676
|
+
colorTargetFormat: TextureFormatValue,
|
|
1677
|
+
): RendererWGPU;
|
|
1678
|
+
/// Gives back the reference WebGPU.importJsTexture returned for a texture.
|
|
1679
|
+
releaseImportedTexture(texture: number): void;
|
|
1680
|
+
renderSplatSetToSceneTextures(
|
|
1681
|
+
splatSet: SplatSet,
|
|
1682
|
+
renderState: RenderState,
|
|
1683
|
+
colorTarget: number,
|
|
1684
|
+
depthTarget: number,
|
|
1685
|
+
renderGES: boolean,
|
|
1686
|
+
): void;
|
|
1687
|
+
// Render view registry, indexed as RenderViews.h orders it. setRenderView ignores an index
|
|
1688
|
+
// Shark cannot produce.
|
|
1689
|
+
setRenderView(viewIndex: number): void;
|
|
1690
|
+
renderView(): number;
|
|
1691
|
+
renderViewCount(): number;
|
|
1692
|
+
renderViewName(viewIndex: number): string;
|
|
1693
|
+
renderViewSupported(viewIndex: number): boolean;
|
|
1694
|
+
// The next supported view, forwards for direction 1 and backwards for -1.
|
|
1695
|
+
stepRenderView(from: number, direction: number): number;
|
|
1696
|
+
// Mesh Views, TrainedMesh.h's TRAINED_MESH_VIEW_* in order.
|
|
1697
|
+
trainedMeshViewCount(): number;
|
|
1698
|
+
trainedMeshViewName(view: number): string;
|
|
1699
|
+
isTrainedMeshLossView(view: number): boolean;
|
|
1700
|
+
isTrainedMeshOverrideColourView(view: number): boolean;
|
|
1701
|
+
}
|
|
1702
|
+
|
|
1703
|
+
declare interface SharkRenderInfo {
|
|
1704
|
+
triangles: number;
|
|
1705
|
+
}
|
|
1706
|
+
|
|
1707
|
+
export declare interface SnapshotData {
|
|
1708
|
+
readonly averageMainThreadTime: number;
|
|
1709
|
+
readonly averageActiveStreamCount: number;
|
|
1710
|
+
readonly averageFps: number;
|
|
1711
|
+
readonly averageVisibleNodes: number;
|
|
1712
|
+
readonly averageVisibleSplats: number;
|
|
1713
|
+
readonly averageCacheUsedBytes: number;
|
|
1714
|
+
readonly averageHeapUsedBytes: number;
|
|
1715
|
+
readonly averageHeapTotalBytes: number;
|
|
1716
|
+
}
|
|
1717
|
+
|
|
1718
|
+
export declare class SnapshotEntry extends Entry {
|
|
1719
|
+
#private;
|
|
1720
|
+
static [Symbol.hasInstance](value: unknown): value is MetricsSnapshotEntry;
|
|
1721
|
+
constructor(init: SnapshotEntryInit);
|
|
1722
|
+
/* Excluded from this release type: _enqueue */
|
|
1723
|
+
}
|
|
1724
|
+
|
|
1725
|
+
export declare type SnapshotEntryInit = EntryInit & {
|
|
1726
|
+
duration: DOMHighResTimeStamp;
|
|
1727
|
+
data: SnapshotData;
|
|
1728
|
+
};
|
|
1729
|
+
|
|
1730
|
+
declare interface SortTypeValue {
|
|
1731
|
+
value: number;
|
|
1732
|
+
}
|
|
1733
|
+
|
|
1734
|
+
/** @deprecated Use clientAttributeList. */
|
|
1735
|
+
export declare const sparkAttributeList: Record<string, ClientAttributeInfo>;
|
|
624
1736
|
|
|
625
1737
|
declare interface SpatialFormat extends EmbindObject {
|
|
626
1738
|
metersPerUnit: number;
|
|
@@ -629,11 +1741,94 @@ declare interface SpatialFormat extends EmbindObject {
|
|
|
629
1741
|
handedness: number;
|
|
630
1742
|
}
|
|
631
1743
|
|
|
1744
|
+
declare interface SplatSet {
|
|
1745
|
+
splatCount: number;
|
|
1746
|
+
// Number of splats actually drawn: ordering[0, activeSplats) holds the unmasked splat indices.
|
|
1747
|
+
// Set alongside orderingView() to restrict the draw to unmasked octant ranges.
|
|
1748
|
+
activeSplats: number;
|
|
1749
|
+
// Selects which ellipsoid layout to allocate and what ellipsoidsView() exposes:
|
|
1750
|
+
// packed (16 bytes/splat) or uncompressed (48). Must be set before the first resize.
|
|
1751
|
+
usePackedEllipsoids: boolean;
|
|
1752
|
+
// direct-write upload: resize -> write into the views -> finalize.
|
|
1753
|
+
// views are valid only until the next resize.
|
|
1754
|
+
resize(splatCount: number): void;
|
|
1755
|
+
ellipsoidsView(): Uint32Array;
|
|
1756
|
+
colorsView(): Uint32Array;
|
|
1757
|
+
sh1View(): Uint32Array;
|
|
1758
|
+
sh2View(): Uint32Array;
|
|
1759
|
+
sh3aView(): Uint32Array;
|
|
1760
|
+
sh3bView(): Uint32Array;
|
|
1761
|
+
// mod_depth is a half-float per primitive slot (dense, padded for non-surfels), so this is a
|
|
1762
|
+
// Uint16Array unlike every other view here -- do not address it with the uint32 splat strides
|
|
1763
|
+
// used for ellipsoids/colors/sh*.
|
|
1764
|
+
modDepthView(): Uint16Array;
|
|
1765
|
+
// Per-chunk fade (opacity multiplier), one float per chunk, defaults to 1.0.
|
|
1766
|
+
// Also sizes the chunk slot to model root slot map below, since both are indexed by chunk slot
|
|
1767
|
+
resizeChunkFades(chunkCount: number): void;
|
|
1768
|
+
chunkFadesView(): Float32Array;
|
|
1769
|
+
// Per-splat chunk index, defaults to slot 0. Write before finalize()
|
|
1770
|
+
chunkIndicesView(): Int32Array;
|
|
1771
|
+
// Model transforms, resolved per splat as
|
|
1772
|
+
// modelRootTransforms[chunkModelRoots[chunkIndices[splat]]]
|
|
1773
|
+
// Slot 0 of both tables is reserved as identity, so real slots start at 1 and a set that
|
|
1774
|
+
// never writes them renders untransformed.
|
|
1775
|
+
resizeModelRootSlots(modelRootCount: number): void;
|
|
1776
|
+
// 16 floats per model root, COLUMN-major - i.e. write THREE's Matrix4.toArray() straight in
|
|
1777
|
+
modelRootTransformsView(): Float32Array;
|
|
1778
|
+
// The inverses, same slots and layout. The true-perspective projection (Project.glsl) transforms
|
|
1779
|
+
// a quadratic form and needs them; writing a transform without its inverse leaves that path
|
|
1780
|
+
// projecting the splat as if untransformed. Use Matrix4.invert() on a copy
|
|
1781
|
+
modelRootInverseTransformsView(): Float32Array;
|
|
1782
|
+
// Sized by resizeChunkFades. Defaults to slot 0 (identity) for every chunk
|
|
1783
|
+
chunkModelRootsView(): Int32Array;
|
|
1784
|
+
// resizeModelRootSlots resets every slot to the absolute decode. False for a slot outside the table
|
|
1785
|
+
setModelRootRootRelativeDecode(
|
|
1786
|
+
slot: number,
|
|
1787
|
+
originX: number,
|
|
1788
|
+
originY: number,
|
|
1789
|
+
originZ: number,
|
|
1790
|
+
step: number,
|
|
1791
|
+
lnScaleOffset: number,
|
|
1792
|
+
): boolean;
|
|
1793
|
+
// int32 render-order buffer (sized 2*splatCount after finalize). Valid only until the next resize.
|
|
1794
|
+
orderingView(): Int32Array;
|
|
1795
|
+
finalize(): void;
|
|
1796
|
+
// like finalize() but keeps splats in their delivered (octant-sorted) order — no kd-tree reorder —
|
|
1797
|
+
// so sparse-octant range masking can index child-octant ranges directly. RADIX_SORT only.
|
|
1798
|
+
finalizeBounds(): void;
|
|
1799
|
+
// Whether the asset carries per-surfel reflectance records, which is what decides whether
|
|
1800
|
+
// reflections are shaded at all. Pass to RenderState.uploadReflectionLadderParams.
|
|
1801
|
+
hasReflectionParams(): boolean;
|
|
1802
|
+
// Widens packed reflectance records - recordVersion 2 for 18-byte reflectanceDataV2, 1 for
|
|
1803
|
+
// 26-byte reflectanceDataV1 - into the per-splat GPU records at bufferOffset. wirePtr must
|
|
1804
|
+
// address THIS module's heap - _malloc here and copy the bytes in, since the attribute lives in
|
|
1805
|
+
// the engine module's. Records cover a node's surfel range, which starts at its first splat.
|
|
1806
|
+
// Returns the records written; 0 if the data was rejected.
|
|
1807
|
+
decodeReflectionParams(
|
|
1808
|
+
recordVersion: number,
|
|
1809
|
+
wirePtr: number,
|
|
1810
|
+
wireSizeBytes: number,
|
|
1811
|
+
elementCount: number,
|
|
1812
|
+
bufferOffset: number,
|
|
1813
|
+
nodeSplatCount: number,
|
|
1814
|
+
logId: number,
|
|
1815
|
+
): number;
|
|
1816
|
+
// Zeroes records in [startSplat, endSplat). Needed wherever splats are re-packed at fresh
|
|
1817
|
+
// offsets, or a reused slot shades its splat from the previous occupant's material.
|
|
1818
|
+
clearReflectionParams(startSplat: number, endSplat: number): void;
|
|
1819
|
+
// Splats in [0, count) holding a non-zero record. Diagnostic.
|
|
1820
|
+
populatedReflectionParamCount(count: number): number;
|
|
1821
|
+
// Overwrites the RGB of splats [start, start + count) from count * 3 bytes at rgbPtr in this
|
|
1822
|
+
// module's heap, each byte 0-255 mapping to 0-1, and keeps alpha. False, writing nothing, for a
|
|
1823
|
+
// range outside the resident splats. Reaches the GPU with the next uploadSplatSetData whose
|
|
1824
|
+
// start is at most start.
|
|
1825
|
+
writeColours(start: number, count: number, rgbPtr: number): boolean;
|
|
1826
|
+
delete(): void;
|
|
1827
|
+
}
|
|
1828
|
+
|
|
632
1829
|
export declare class Stream extends EventTarget {
|
|
633
1830
|
#private;
|
|
634
|
-
static readonly _idMap: Map<number, Stream>;
|
|
635
1831
|
static readonly _keyMap: Map<unknown, Stream>;
|
|
636
|
-
static forId(id?: number): Stream | undefined;
|
|
637
1832
|
static forKey(key: unknown): Stream | undefined;
|
|
638
1833
|
readonly id: number;
|
|
639
1834
|
readonly scene: Scene;
|
|
@@ -651,6 +1846,9 @@ export declare class Stream extends EventTarget {
|
|
|
651
1846
|
set matrix(matrix: Matrix4x4Tuple);
|
|
652
1847
|
get opacity(): number;
|
|
653
1848
|
set opacity(opacity: number);
|
|
1849
|
+
get fetchMode(): StreamFetchMode;
|
|
1850
|
+
set fetchMode(fetchMode: StreamFetchMode);
|
|
1851
|
+
/* Excluded from this release type: _applyFetchMode */
|
|
654
1852
|
get boundingBox(): {
|
|
655
1853
|
min: {
|
|
656
1854
|
x: number;
|
|
@@ -683,11 +1881,23 @@ export declare class Stream extends EventTarget {
|
|
|
683
1881
|
/* Excluded from this release type: _onStreamLoaded */
|
|
684
1882
|
getDefaultCameraTransform(): Float32Array<ArrayBuffer> | null | undefined;
|
|
685
1883
|
/* Excluded from this release type: _getViewingVolumeObb */
|
|
1884
|
+
/** How much of the stream has loaded, as of the last frame. */
|
|
1885
|
+
get readyState(): ReadyState_2;
|
|
1886
|
+
/* Excluded from this release type: _updateStatus */
|
|
686
1887
|
/* Excluded from this release type: _onRootLoaded */
|
|
687
1888
|
add(modelRoot: ModelRoot): void;
|
|
688
1889
|
end(): void;
|
|
689
1890
|
}
|
|
690
1891
|
|
|
1892
|
+
/**
|
|
1893
|
+
* What the engine will do with stream data: "regular" fetches and draws what the
|
|
1894
|
+
* camera needs. "prefetch" keeps fetching for the camera into the cache but does not change what is drawn.
|
|
1895
|
+
* "parked" fetches nothing and draws nothing, giving its share of the splat budget and
|
|
1896
|
+
* renderer to the other streams; what it already loaded stays cached on the cpu side for when it is unparked.
|
|
1897
|
+
* You may want to park streams while making them invisible.
|
|
1898
|
+
*/
|
|
1899
|
+
export declare type StreamFetchMode = "regular" | "prefetch" | "parked";
|
|
1900
|
+
|
|
691
1901
|
export declare type StreamInit = {
|
|
692
1902
|
uuid: string;
|
|
693
1903
|
scene: Scene;
|
|
@@ -697,6 +1907,107 @@ export declare type StreamInit = {
|
|
|
697
1907
|
|
|
698
1908
|
declare type StringVector = EmbindVector<string>;
|
|
699
1909
|
|
|
1910
|
+
export declare type TargetType = MetricsTargetType;
|
|
1911
|
+
|
|
1912
|
+
export declare type TelemetryTarget = MirisTarget | SceneTarget | ObjectTarget;
|
|
1913
|
+
|
|
1914
|
+
declare interface TextureFormatValue {
|
|
1915
|
+
value: number;
|
|
1916
|
+
}
|
|
1917
|
+
|
|
1918
|
+
declare const TIMING_NAME_ORDINAL: {
|
|
1919
|
+
readonly initialize: 0;
|
|
1920
|
+
readonly load: 1;
|
|
1921
|
+
readonly "first-pixel": 2;
|
|
1922
|
+
readonly stable: 3;
|
|
1923
|
+
readonly decode: 4;
|
|
1924
|
+
};
|
|
1925
|
+
|
|
1926
|
+
export declare class TimingEntry extends Entry {
|
|
1927
|
+
#private;
|
|
1928
|
+
static [Symbol.hasInstance](value: unknown): value is MetricsTimingEntry;
|
|
1929
|
+
constructor(init: TimingEntryInit);
|
|
1930
|
+
/* Excluded from this release type: _enqueue */
|
|
1931
|
+
}
|
|
1932
|
+
|
|
1933
|
+
export declare type TimingEntryInit = EntryInit & {
|
|
1934
|
+
target: TelemetryTarget;
|
|
1935
|
+
name: TimingEntryName;
|
|
1936
|
+
duration: DOMHighResTimeStamp;
|
|
1937
|
+
};
|
|
1938
|
+
|
|
1939
|
+
export declare type TimingEntryName = keyof typeof TIMING_NAME_ORDINAL;
|
|
1940
|
+
|
|
1941
|
+
declare interface TrainedMeshStreamRegistry {
|
|
1942
|
+
registerMesh(objectId: number, bytesPtr: number, byteCount: number): boolean;
|
|
1943
|
+
registerDecoder(
|
|
1944
|
+
decoderPtr: number,
|
|
1945
|
+
decoderByteCount: number,
|
|
1946
|
+
mapPtr: number,
|
|
1947
|
+
mapByteCount: number,
|
|
1948
|
+
): boolean;
|
|
1949
|
+
// ALOS per-vertex training loss, which the loss overlay writes into features0.
|
|
1950
|
+
registerLoss(bytesPtr: number, byteCount: number): boolean;
|
|
1951
|
+
setLossOverlay(enabled: boolean): void;
|
|
1952
|
+
hasLoss(): boolean;
|
|
1953
|
+
// The loss a channel's (p10, p50, p90) level 0 and level 1 stand for, or -1 without loss.
|
|
1954
|
+
lossLow(channel: number): number;
|
|
1955
|
+
lossHigh(channel: number): number;
|
|
1956
|
+
// vertexCount RGB bytes a vertex for one (piece, level) copy, kept across streaming; false for a
|
|
1957
|
+
// count other than the drawn copy's. Copied before returning.
|
|
1958
|
+
setPieceColours(
|
|
1959
|
+
pieceId: number,
|
|
1960
|
+
level: number,
|
|
1961
|
+
rgbPtr: number,
|
|
1962
|
+
vertexCount: number,
|
|
1963
|
+
): boolean;
|
|
1964
|
+
clearColours(): void;
|
|
1965
|
+
// On, the "Override colour" Mesh View draws the supplied colours, magenta for a copy without.
|
|
1966
|
+
setColourOverride(enabled: boolean): void;
|
|
1967
|
+
isColourOverride(): boolean;
|
|
1968
|
+
// As "id,level,vertexCount;...": the copies in one node, or in every resident node.
|
|
1969
|
+
nodePieces(objectId: number): string;
|
|
1970
|
+
residentPieces(): string;
|
|
1971
|
+
removeObject(objectId: number): boolean;
|
|
1972
|
+
clear(): void;
|
|
1973
|
+
isDrawable(): boolean;
|
|
1974
|
+
uploadIfChanged(renderState: RenderState): void;
|
|
1975
|
+
// For a mesh drawn from a cluster LOD pool, which has no pieces to upload the decoder with.
|
|
1976
|
+
uploadDecoderAlone(renderState: RenderState): void;
|
|
1977
|
+
drawTriangleCount(): number;
|
|
1978
|
+
residentNodeCount(): number;
|
|
1979
|
+
residentPayloadBytes(): number;
|
|
1980
|
+
drawnPiecesByLevel(): string;
|
|
1981
|
+
// As of the last upload: the drawn piece ids ascending as "a;b;c", and the node drawing a piece
|
|
1982
|
+
// (-1 for none).
|
|
1983
|
+
drawnPieceIds(): string;
|
|
1984
|
+
drawnPieceObjectId(pieceId: number): number;
|
|
1985
|
+
// The drawn piece a ray in the mesh's own frame hits first, or -1.
|
|
1986
|
+
pickPiece(
|
|
1987
|
+
originX: number,
|
|
1988
|
+
originY: number,
|
|
1989
|
+
originZ: number,
|
|
1990
|
+
directionX: number,
|
|
1991
|
+
directionY: number,
|
|
1992
|
+
directionZ: number,
|
|
1993
|
+
): number;
|
|
1994
|
+
delete(): void;
|
|
1995
|
+
}
|
|
1996
|
+
|
|
1997
|
+
export declare class TransformationEntry extends Entry {
|
|
1998
|
+
#private;
|
|
1999
|
+
static [Symbol.hasInstance](value: unknown): value is MetricsTransformationEntry;
|
|
2000
|
+
constructor(init: TransformationEntryInit);
|
|
2001
|
+
/* Excluded from this release type: _enqueue */
|
|
2002
|
+
}
|
|
2003
|
+
|
|
2004
|
+
export declare type TransformationEntryInit = EntryInit & {
|
|
2005
|
+
target: ObjectTarget;
|
|
2006
|
+
position: [number, number, number];
|
|
2007
|
+
quaternion: [number, number, number, number];
|
|
2008
|
+
scale: [number, number, number];
|
|
2009
|
+
};
|
|
2010
|
+
|
|
700
2011
|
/** Recursive variant tree node from WASM. */
|
|
701
2012
|
export declare type VariantNode = {
|
|
702
2013
|
id: number;
|
|
@@ -707,4 +2018,18 @@ export declare type VariantNode = {
|
|
|
707
2018
|
nestedSets?: VariantNode[];
|
|
708
2019
|
};
|
|
709
2020
|
|
|
2021
|
+
declare interface vec4 {
|
|
2022
|
+
x: number;
|
|
2023
|
+
y: number;
|
|
2024
|
+
z: number;
|
|
2025
|
+
w: number;
|
|
2026
|
+
delete(): void;
|
|
2027
|
+
}
|
|
2028
|
+
|
|
2029
|
+
declare interface WebGPUInterface {
|
|
2030
|
+
importJsAdapter(adapter: GPUAdapter, parentPtr?: number): number;
|
|
2031
|
+
importJsDevice(device: GPUDevice, parentPtr?: number): number;
|
|
2032
|
+
importJsTexture(obj: GPUTexture, parentPtr?: number): number;
|
|
2033
|
+
}
|
|
2034
|
+
|
|
710
2035
|
export { }
|