@miris-inc/core 0.0.8-fd62089 → 0.0.8-fdd3ff0
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 +434 -17
- package/dist/core.js +345 -78
- package/dist/core.prod.js +1 -1
- package/dist/core.standalone.js +4104 -2111
- package/dist/core.standalone.prod.js +1 -1
- package/package.json +1 -8
- package/webshark.d.ts +0 -290
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,10 @@ 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;
|
|
36
41
|
static readonly GLASS_MESH_GEOMETRY: string;
|
|
37
42
|
static readonly GLASS_MESH_PANELS: string;
|
|
38
43
|
static readonly MOD_DEPTH: string;
|
|
@@ -65,6 +70,18 @@ export declare class Camera {
|
|
|
65
70
|
constructor({ aspect, fov, near, far, matrix, scene, viewportHeight, }: CameraInit);
|
|
66
71
|
}
|
|
67
72
|
|
|
73
|
+
declare interface Camera_2 {
|
|
74
|
+
dir: vec4;
|
|
75
|
+
U: vec4;
|
|
76
|
+
V: vec4;
|
|
77
|
+
eye: vec4;
|
|
78
|
+
l: number;
|
|
79
|
+
fov: number;
|
|
80
|
+
zNear: number;
|
|
81
|
+
zFar: number;
|
|
82
|
+
delete(): void;
|
|
83
|
+
}
|
|
84
|
+
|
|
68
85
|
export declare type CameraInit = {
|
|
69
86
|
aspect: number;
|
|
70
87
|
fov: number;
|
|
@@ -92,7 +109,7 @@ declare class Client {
|
|
|
92
109
|
readonly handle: AquaClientHandle;
|
|
93
110
|
get viewerKey(): string | null;
|
|
94
111
|
set viewerKey(key: string | null);
|
|
95
|
-
constructor({ engine, context }: ClientInit);
|
|
112
|
+
constructor({ engine, context, id }: ClientInit);
|
|
96
113
|
dispose(): void;
|
|
97
114
|
addStreamById(...args: ClientMethodParameters["addStreamById"]): number;
|
|
98
115
|
destroyClient(...args: ClientMethodParameters["destroyClient"]): AquaStatus;
|
|
@@ -108,7 +125,9 @@ declare class Client {
|
|
|
108
125
|
getSceneMetadata(...args: ClientMethodParameters["getSceneMetadata"]): number;
|
|
109
126
|
getSceneObjectParent(...args: ClientMethodParameters["getSceneObjectParent"]): number;
|
|
110
127
|
getSceneObjectType(...args: ClientMethodParameters["getSceneObjectType"]): SceneObjectType;
|
|
128
|
+
getStreamStatus(...args: ClientMethodParameters["getStreamStatus"]): StreamStatus;
|
|
111
129
|
getDrawnOctantMask(...args: ClientMethodParameters["getDrawnOctantMask"]): number;
|
|
130
|
+
getOctantLocalBoundingBoxes(...args: ClientMethodParameters["getOctantLocalBoundingBoxes"]): number[];
|
|
112
131
|
getLocalTransform(...args: ClientMethodParameters["getLocalTransform"]): AquaStatus;
|
|
113
132
|
getWorldTransform(...args: ClientMethodParameters["getWorldTransform"]): AquaStatus;
|
|
114
133
|
hasAttribute(...args: ClientMethodParameters["hasAttribute"]): boolean;
|
|
@@ -118,6 +137,8 @@ declare class Client {
|
|
|
118
137
|
setAssetViewerKey(...args: ClientMethodParameters["setAssetViewerKey"]): AquaStatus;
|
|
119
138
|
setClientSpatialFormat(...args: ClientMethodParameters["setClientSpatialFormat"]): AquaStatus;
|
|
120
139
|
setRuntimeSettings(...args: ClientMethodParameters["setRuntimeSettings"]): AquaStatus;
|
|
140
|
+
setStreamFetchMode(...args: ClientMethodParameters["setStreamFetchMode"]): boolean;
|
|
141
|
+
getStreamFetchMode(...args: ClientMethodParameters["getStreamFetchMode"]): number;
|
|
121
142
|
setMainCameraTransform(...args: ClientMethodParameters["setMainCameraTransform"]): AquaStatus;
|
|
122
143
|
setMainCameraViewFrustum(...args: ClientMethodParameters["setMainCameraViewFrustum"]): AquaStatus;
|
|
123
144
|
setSceneObjectTransform(...args: ClientMethodParameters["setSceneObjectTransform"]): AquaStatus;
|
|
@@ -135,9 +156,18 @@ declare class Client {
|
|
|
135
156
|
updateSceneExecution(...args: ClientMethodParameters["updateSceneExecution"]): AquaStatus;
|
|
136
157
|
}
|
|
137
158
|
|
|
159
|
+
declare type ClientAttributeInfo = {
|
|
160
|
+
elementsPerSplat: number;
|
|
161
|
+
discard: boolean;
|
|
162
|
+
bytes?: true;
|
|
163
|
+
};
|
|
164
|
+
|
|
165
|
+
export declare const clientAttributeList: Record<string, ClientAttributeInfo>;
|
|
166
|
+
|
|
138
167
|
declare type ClientInit = {
|
|
139
168
|
engine: Engine;
|
|
140
169
|
context?: AquaContextHandle;
|
|
170
|
+
id: number;
|
|
141
171
|
};
|
|
142
172
|
|
|
143
173
|
declare type ClientMethodParameters<Parameters extends EngineMethodParameters = EngineMethodParameters> = {
|
|
@@ -184,6 +214,7 @@ declare class Engine {
|
|
|
184
214
|
readonly DrMap: 0;
|
|
185
215
|
readonly ReflMesh: 1;
|
|
186
216
|
readonly GlassMesh: 2;
|
|
217
|
+
readonly RenderAsPointCloud: 3;
|
|
187
218
|
};
|
|
188
219
|
static FeatureState: {
|
|
189
220
|
readonly NotLoaded: 0;
|
|
@@ -191,11 +222,28 @@ declare class Engine {
|
|
|
191
222
|
readonly Loaded: 2;
|
|
192
223
|
readonly Failed: 3;
|
|
193
224
|
};
|
|
225
|
+
static StreamStatus: {
|
|
226
|
+
readonly Unknown: 0;
|
|
227
|
+
readonly Resolving: 1;
|
|
228
|
+
readonly Loading: 2;
|
|
229
|
+
readonly Ready: 3;
|
|
230
|
+
readonly Failed: 4;
|
|
231
|
+
};
|
|
232
|
+
static StreamFetchMode: {
|
|
233
|
+
readonly Regular: 0;
|
|
234
|
+
readonly Prefetch: 1;
|
|
235
|
+
readonly Parked: 2;
|
|
236
|
+
};
|
|
194
237
|
readonly ready: Promise<this>;
|
|
195
238
|
readonly pending: boolean;
|
|
196
239
|
get module(): MainModule;
|
|
197
240
|
constructor(moduleOptions?: Record<string, unknown>);
|
|
198
241
|
get AttributeInfo(): new () => AttributeInfo;
|
|
242
|
+
get CompressionType(): {
|
|
243
|
+
SHARK_ELLIPSOID_COMPRESSED: unknown;
|
|
244
|
+
SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE: unknown;
|
|
245
|
+
SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE_V2: unknown;
|
|
246
|
+
};
|
|
199
247
|
get Handedness(): {
|
|
200
248
|
Right: number;
|
|
201
249
|
Left: number;
|
|
@@ -216,6 +264,7 @@ declare class Engine {
|
|
|
216
264
|
Y: number;
|
|
217
265
|
Z: number;
|
|
218
266
|
};
|
|
267
|
+
get UsePadding(): boolean;
|
|
219
268
|
activatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
220
269
|
addStreamById(...args: [
|
|
221
270
|
handle: AquaClientHandle,
|
|
@@ -226,13 +275,15 @@ declare class Engine {
|
|
|
226
275
|
allocateSceneChangesArrays(...args: [sceneChangeIds: SceneChangeIds]): void;
|
|
227
276
|
createContext(...args: []): AquaContextHandle;
|
|
228
277
|
destroyContext(...args: [handle: AquaContextHandle]): AquaStatus;
|
|
229
|
-
|
|
278
|
+
/** telemetryCollector, a collector handle or 0 for none, must outlive the client. */
|
|
279
|
+
createClient(id: number, context?: AquaContextHandle, telemetryCollector?: number): AquaClientHandle;
|
|
230
280
|
createdObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
231
281
|
deletedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
232
282
|
dataPtrView(...args: [attributeInfo: AttributeInfo]): Uint32Array;
|
|
233
283
|
deactivatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
234
284
|
remaskedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
|
|
235
285
|
getDrawnOctantMask(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
|
|
286
|
+
getOctantLocalBoundingBoxes(...args: [handle: AquaClientHandle, sceneObjectId: number]): number[];
|
|
236
287
|
destroyClient(...args: [handle: AquaClientHandle]): AquaStatus;
|
|
237
288
|
free(...args: [size: number]): number;
|
|
238
289
|
getAssetsAsync(...args: [handle: AquaClientHandle, tags: StringVector]): AssetInfo[];
|
|
@@ -251,6 +302,7 @@ declare class Engine {
|
|
|
251
302
|
getSceneChangesCounts(...args: [handle: AquaClientHandle, sceneChangeIds: SceneChangeIds]): void;
|
|
252
303
|
getSceneMetadata(...args: [handle: AquaClientHandle, metadata: SceneMetadata]): number;
|
|
253
304
|
getSceneObjectParent(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
|
|
305
|
+
getStreamStatus(...args: [handle: AquaClientHandle, streamObjectId: number]): StreamStatus;
|
|
254
306
|
getSceneObjectType(...args: [handle: AquaClientHandle, sceneObjectId: number]): SceneObjectType;
|
|
255
307
|
getLocalTransform(...args: [
|
|
256
308
|
handle: AquaClientHandle,
|
|
@@ -302,8 +354,11 @@ declare class Engine {
|
|
|
302
354
|
farPlane: number,
|
|
303
355
|
viewportHeightPixels: number
|
|
304
356
|
]): AquaStatus;
|
|
357
|
+
setStreamFetchMode(...args: [handle: AquaClientHandle, streamObjectId: number, mode: number]): boolean;
|
|
358
|
+
getStreamFetchMode(...args: [handle: AquaClientHandle, streamObjectId: number]): number;
|
|
305
359
|
setMaxCacheSize(...args: [maxSizeBytes: number]): void;
|
|
306
360
|
setPreferSharkEncodingProfiles(...args: [preferShark: boolean]): void;
|
|
361
|
+
setPadSplatAttributes(usePadding: boolean): void;
|
|
307
362
|
setSceneObjectTransform(...args: [
|
|
308
363
|
handle: AquaClientHandle,
|
|
309
364
|
sceneObjectId: number,
|
|
@@ -332,9 +387,16 @@ declare class Engine {
|
|
|
332
387
|
* displayed frame per context, before the per-client updateSceneExecution() calls.
|
|
333
388
|
* `previousFrameTimeMs` is how long the previous frame took; pass 0 when there is no plausible
|
|
334
389
|
* measurement (first frame, or a resume from a stall) and the frame advances without recording
|
|
335
|
-
*
|
|
390
|
+
* `primsResident` is what the renderer held at the end of the previous frame, fading
|
|
391
|
+
* prims included, and `primCapacity` what it can hold; activations that would not fit are
|
|
392
|
+
* deferred, where primCapacity 0 means deferral is disabled.
|
|
336
393
|
*/
|
|
337
|
-
beginFrame(...args: [
|
|
394
|
+
beginFrame(...args: [
|
|
395
|
+
contextHandle: AquaContextHandle,
|
|
396
|
+
previousFrameTimeMs: number,
|
|
397
|
+
primsResident: number,
|
|
398
|
+
primCapacity: number
|
|
399
|
+
]): AquaStatus;
|
|
338
400
|
createDeserializeWorker(_url: string, _workerUrl: string, poolSize: number): boolean;
|
|
339
401
|
cancelRequest(requestIdLow: number, requestIdHigh: number): boolean;
|
|
340
402
|
submitToWorker(requestIdLow: number, requestIdHigh: number, descriptorBuffer: ArrayBuffer, contextPtr: number): boolean;
|
|
@@ -348,6 +410,52 @@ declare type EngineMethodParameters<E extends Engine = Engine> = {
|
|
|
348
410
|
[Key in keyof E]: E[Key] extends (...args: any[]) => any ? Parameters<E[Key]> : never;
|
|
349
411
|
};
|
|
350
412
|
|
|
413
|
+
declare interface GlassMeshRegistry {
|
|
414
|
+
// Decodes one octree node's glass payload and registers it, replacing any previous entry for
|
|
415
|
+
// that object. False for a malformed or empty payload, leaving the registry unchanged.
|
|
416
|
+
//
|
|
417
|
+
// The two slot arguments are different numbers here, unlike on the native path, and swapping
|
|
418
|
+
// them renders glass that does not follow its asset: modelRootSlot scopes the panel dedupe to
|
|
419
|
+
// one asset instance, while chunkModelRootIndex is stamped into every vertex and read back as
|
|
420
|
+
// chunkModelRoots[pos.w], so that one takes the chunk's fade slot.
|
|
421
|
+
//
|
|
422
|
+
// geometryPtr/panelPtr address THIS module's heap - _malloc here and copy the bytes in, since
|
|
423
|
+
// the attributes live in the engine module's. The AABB is the geometry attribute's own range.
|
|
424
|
+
registerObject(
|
|
425
|
+
objectId: number,
|
|
426
|
+
lodIndex: number,
|
|
427
|
+
modelRootSlot: number,
|
|
428
|
+
chunkModelRootIndex: number,
|
|
429
|
+
geometryPtr: number,
|
|
430
|
+
geometryByteCount: number,
|
|
431
|
+
panelPtr: number,
|
|
432
|
+
panelByteCount: number,
|
|
433
|
+
aabbMinX: number,
|
|
434
|
+
aabbMinY: number,
|
|
435
|
+
aabbMinZ: number,
|
|
436
|
+
aabbMaxX: number,
|
|
437
|
+
aabbMaxY: number,
|
|
438
|
+
aabbMaxZ: number,
|
|
439
|
+
): boolean;
|
|
440
|
+
// Returns true if the object had glass, which is what says the buffers need rebuilding.
|
|
441
|
+
removeObject(objectId: number): boolean;
|
|
442
|
+
clear(): void;
|
|
443
|
+
isDirty(): boolean;
|
|
444
|
+
// Rebuilds the flattened buffers, keeping each panel from its deepest resident LOD. Stays dirty
|
|
445
|
+
// so uploadIfDirty still fires. Walks every registered object, so not per frame.
|
|
446
|
+
flattenIfDirty(): void;
|
|
447
|
+
uploadIfDirty(renderState: RenderState): void;
|
|
448
|
+
vertexCount(): number;
|
|
449
|
+
panelCount(): number;
|
|
450
|
+
delete(): void;
|
|
451
|
+
}
|
|
452
|
+
|
|
453
|
+
export declare const HaveData = 2;
|
|
454
|
+
|
|
455
|
+
export declare const HaveMetadata = 1;
|
|
456
|
+
|
|
457
|
+
export declare const HaveNothing = 0;
|
|
458
|
+
|
|
351
459
|
export declare class Lod {
|
|
352
460
|
#private;
|
|
353
461
|
readonly id: LodInit["id"];
|
|
@@ -378,10 +486,14 @@ export declare class Lod {
|
|
|
378
486
|
get transform(): Float32Array<ArrayBuffer> | null;
|
|
379
487
|
get _drawnOctantMask(): number;
|
|
380
488
|
set _drawnOctantMask(mask: number);
|
|
489
|
+
get _octantLocalBounds(): Float32Array<ArrayBuffer> | null;
|
|
490
|
+
set _octantLocalBounds(bounds: Float32Array<ArrayBuffer> | null);
|
|
381
491
|
get _octantOffsets(): Uint32Array<ArrayBuffer> | null;
|
|
382
492
|
get _hasOctantOffsets(): boolean;
|
|
383
493
|
get _surfelOctantOffsets(): Uint32Array<ArrayBuffer> | null;
|
|
384
494
|
get _surfelCount(): number;
|
|
495
|
+
get _surfelOwnerGroups(): Uint32Array<ArrayBuffer> | null;
|
|
496
|
+
get _octantCell(): Uint32Array<ArrayBuffer> | null;
|
|
385
497
|
_readOctantOffsets(engine: Engine): void;
|
|
386
498
|
hasAttribute(attributeName: string): boolean;
|
|
387
499
|
getDataFromAttribute(engine: Engine, attributeName: string, attributeInfo: AttributeInfo): CachedAttribute | null;
|
|
@@ -409,8 +521,13 @@ export declare class LodStore {
|
|
|
409
521
|
deleteId(id: number): void;
|
|
410
522
|
}
|
|
411
523
|
|
|
412
|
-
declare interface MainModule {
|
|
524
|
+
declare interface MainModule extends SharkModule {
|
|
413
525
|
AttributeInfo: new () => AttributeInfo;
|
|
526
|
+
CompressionType: {
|
|
527
|
+
SHARK_ELLIPSOID_COMPRESSED: unknown;
|
|
528
|
+
SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE: unknown;
|
|
529
|
+
SHARK_ELLIPSOID_COMPRESSED_ROOT_RELATIVE_V2: unknown;
|
|
530
|
+
};
|
|
414
531
|
Handedness: { Right: number; Left: number };
|
|
415
532
|
HEAPF32: Float32Array<ArrayBuffer>;
|
|
416
533
|
HEAPU8: Uint8Array<ArrayBuffer>;
|
|
@@ -439,6 +556,7 @@ declare interface MainModule {
|
|
|
439
556
|
remaskedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
|
|
440
557
|
deletedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
|
|
441
558
|
GetDrawnOctantMask(handle: number, sceneObjectId: number): number;
|
|
559
|
+
GetOctantLocalBoundingBoxes(handle: number, sceneObjectId: number): number[];
|
|
442
560
|
GetAssetsAsync(handle: number, tags: StringVector): unknown[];
|
|
443
561
|
GetSceneChanges(handle: number, sceneChangeIds: SceneChangeIds): void;
|
|
444
562
|
GetSceneChangesCounts(handle: number, sceneChangeIds: SceneChangeIds): void;
|
|
@@ -451,10 +569,17 @@ declare interface MainModule {
|
|
|
451
569
|
GetDrMapLadderRoughnessLevels(handle: number, sceneObjectId: number): number[];
|
|
452
570
|
SetClientSpatialFormat(handle: number, spatialFormat: SpatialFormat): { value: number };
|
|
453
571
|
SetRuntimeSettings(handle: number, settings: RuntimeSettings): { value: number };
|
|
572
|
+
SetStreamFetchMode(handle: number, streamObjectId: number, mode: number): boolean;
|
|
573
|
+
GetStreamFetchMode(handle: number, streamObjectId: number): number;
|
|
454
574
|
TakeEvictedClientSideAttributeIds(handle: number): EmbindVector<bigint>;
|
|
455
575
|
GetActiveClientSideIdsCheckSum(): number;
|
|
456
576
|
TakeRenderRequired(handle: number): boolean;
|
|
457
|
-
BeginFrame(
|
|
577
|
+
BeginFrame(
|
|
578
|
+
contextHandle: number,
|
|
579
|
+
previousFrameTimeMs: number,
|
|
580
|
+
primsResident: number,
|
|
581
|
+
primCapacity: number,
|
|
582
|
+
): number;
|
|
458
583
|
modifiedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
|
|
459
584
|
setMaxCacheSize(maxSizeBytes: number): void;
|
|
460
585
|
SetPreferSharkEncodingProfiles(prefer: boolean): void;
|
|
@@ -480,6 +605,7 @@ export declare class Miris {
|
|
|
480
605
|
get viewerKey(): string | null | undefined;
|
|
481
606
|
set viewerKey(viewerKey: string | null | undefined);
|
|
482
607
|
get scenes(): Set<Scene>;
|
|
608
|
+
/* Excluded from this release type: _createNewClientId */
|
|
483
609
|
get useSphericalHarmonics(): boolean;
|
|
484
610
|
set useSphericalHarmonics(value: boolean);
|
|
485
611
|
constructor();
|
|
@@ -496,15 +622,20 @@ export declare class Miris {
|
|
|
496
622
|
static readonly _XR_TARGET_FRAME_RATE = 43;
|
|
497
623
|
/* Excluded from this release type: _XR_SPLAT_COUNT_BUDGET */
|
|
498
624
|
/* Excluded from this release type: _SHARK_SPLAT_CAPACITY_MOBILE */
|
|
499
|
-
static readonly _SHARK_SPLAT_CAPACITY_DESKTOP
|
|
625
|
+
static readonly _SHARK_SPLAT_CAPACITY_DESKTOP: number;
|
|
500
626
|
/* Excluded from this release type: _SHARK_SPLAT_BUDGET_CAP_MOBILE */
|
|
501
|
-
static readonly _SHARK_SPLAT_BUDGET_CAP_DESKTOP =
|
|
627
|
+
static readonly _SHARK_SPLAT_BUDGET_CAP_DESKTOP = 2400000;
|
|
502
628
|
/* Excluded from this release type: _isMobileDevice */
|
|
503
629
|
/* Excluded from this release type: _sharkSplatCapacity */
|
|
630
|
+
/* Excluded from this release type: _minimumSplatCount */
|
|
631
|
+
/* Excluded from this release type: _splatCountStorageKey */
|
|
632
|
+
/* Excluded from this release type: _reloadWithLowerSplatCapacity */
|
|
633
|
+
/* Excluded from this release type: _limitSharkSplatCapacity */
|
|
504
634
|
/* Excluded from this release type: _sharkSplatBudgetCap */
|
|
505
635
|
/* Excluded from this release type: _setTargetFrameRate */
|
|
506
636
|
/* Excluded from this release type: _setXRModeActive */
|
|
507
637
|
/* Excluded from this release type: _setSplatCountBudgetOverride */
|
|
638
|
+
/* Excluded from this release type: _reportRendererPrims */
|
|
508
639
|
/* Excluded from this release type: _update */
|
|
509
640
|
getLocalTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
|
|
510
641
|
getWorldTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
|
|
@@ -541,9 +672,9 @@ export declare type ModelRootInit = {
|
|
|
541
672
|
* The byte-exact counterpart of getRawUint32Attribute above: same no-padding, no-takeAttribute
|
|
542
673
|
* contract, returning bytes rather than words.
|
|
543
674
|
*
|
|
544
|
-
* Use this rather than that one wherever the stride is not a whole number of words:
|
|
545
|
-
*
|
|
546
|
-
* last field to dataPtrView's truncation.
|
|
675
|
+
* Use this rather than that one wherever the stride is not a whole number of words: the
|
|
676
|
+
* reflectance records' 18- and 26-byte strides are not, and an odd record count would lose that
|
|
677
|
+
* record's last field to dataPtrView's truncation.
|
|
547
678
|
*/
|
|
548
679
|
export declare type RawByteAttributeWithBounds = {
|
|
549
680
|
bytes: Uint8Array<ArrayBuffer>;
|
|
@@ -559,6 +690,72 @@ export declare type RawByteAttributeWithBounds = {
|
|
|
559
690
|
};
|
|
560
691
|
};
|
|
561
692
|
|
|
693
|
+
declare type ReadyState_2 = typeof HaveNothing | typeof HaveMetadata | typeof HaveData;
|
|
694
|
+
export { ReadyState_2 as ReadyState }
|
|
695
|
+
|
|
696
|
+
declare interface RendererWGPU {
|
|
697
|
+
getProgramCount(): number;
|
|
698
|
+
getTextureCount(): number;
|
|
699
|
+
getEstimatedTextureSize(): number;
|
|
700
|
+
getTotalBufferSize(): number;
|
|
701
|
+
getGpuBufferSize(): number;
|
|
702
|
+
getUploadBufferSize(): number;
|
|
703
|
+
info: SharkInfo;
|
|
704
|
+
delete(): void;
|
|
705
|
+
}
|
|
706
|
+
|
|
707
|
+
declare interface RenderState {
|
|
708
|
+
delete(): void;
|
|
709
|
+
initRenderState(
|
|
710
|
+
renderer: RendererWGPU,
|
|
711
|
+
width: number,
|
|
712
|
+
height: number,
|
|
713
|
+
vertices: number,
|
|
714
|
+
splats: number,
|
|
715
|
+
cubes: number,
|
|
716
|
+
sortThreads: number,
|
|
717
|
+
sortGroupSize: number,
|
|
718
|
+
sortKeySize: number,
|
|
719
|
+
): void;
|
|
720
|
+
initGraphicsState(
|
|
721
|
+
width: number,
|
|
722
|
+
height: number,
|
|
723
|
+
renderTextureFormat: TextureFormatValue,
|
|
724
|
+
depthTextureFormat: TextureFormatValue,
|
|
725
|
+
): void;
|
|
726
|
+
updateRenderDetails(
|
|
727
|
+
width: number,
|
|
728
|
+
height: number,
|
|
729
|
+
splatTriangles: number,
|
|
730
|
+
): void;
|
|
731
|
+
// Decodes Radiance .hdr bytes into roughness-ladder level `level` (0 is the sharp mirror).
|
|
732
|
+
// hdrPtr must address THIS module's heap - _malloc here and copy the bytes in.
|
|
733
|
+
// Returns false for bytes that are not a usable Radiance image, or a level out of range.
|
|
734
|
+
uploadEnvironmentLadderLevelFromHdr(
|
|
735
|
+
level: number,
|
|
736
|
+
sigmaDeg: number,
|
|
737
|
+
hdrPtr: number,
|
|
738
|
+
hdrSizeBytes: number,
|
|
739
|
+
): boolean;
|
|
740
|
+
// Republish the ladder's shape. Call after any level lands, or it is sampled at whatever shape
|
|
741
|
+
// the last uploadSplatSetData declared. Pass SplatSet.hasReflectionParams().
|
|
742
|
+
uploadReflectionLadderParams(reflectionsEnabled: boolean): void;
|
|
743
|
+
// Debug controls. Drop the reflection term, or replace the surfel colour with one of the layers
|
|
744
|
+
// it is shaded from, numbered as RenderViewModes.h's AOV_* defines. setRenderView below sets
|
|
745
|
+
// the AOV together with the rest of a named view.
|
|
746
|
+
setReflectionsEnabled(enabled: boolean): void;
|
|
747
|
+
// Render textured gaussians on pixels no surfel covers, resolved as fvdb's open gate does.
|
|
748
|
+
// Off by default: those pixels show the clear colour.
|
|
749
|
+
setSurfelLessTextureSplatsEnabled(enabled: boolean): void;
|
|
750
|
+
setDebugAovMode(mode: number): void;
|
|
751
|
+
// GPU pass timing. Turning it on makes every pass write timestamps; a no-op on a device without
|
|
752
|
+
// timestamp-query. resolveTimeStamps goes after a frame's render; passTimingsMs starts a readback
|
|
753
|
+
// of them unless one is in flight and maps pass name to milliseconds from the last that landed.
|
|
754
|
+
setPassTimingEnabled(enabled: boolean): void;
|
|
755
|
+
resolveTimeStamps(): void;
|
|
756
|
+
passTimingsMs(): Record<string, number>;
|
|
757
|
+
}
|
|
758
|
+
|
|
562
759
|
declare type RequestAnimationFrameFn = ((callback: FrameRequestCallback) => number) | ((callback: XRFrameRequestCallback) => void);
|
|
563
760
|
|
|
564
761
|
declare interface RuntimeSettings extends EmbindObject {
|
|
@@ -617,6 +814,8 @@ export declare class Scene extends EventTarget {
|
|
|
617
814
|
/* Excluded from this release type: _getDrMap */
|
|
618
815
|
/* Excluded from this release type: _onDrMapLadder */
|
|
619
816
|
/* Excluded from this release type: _onFeatureData */
|
|
817
|
+
/* Excluded from this release type: _applyStreamFetchModes */
|
|
818
|
+
/* Excluded from this release type: _updateStreamStatuses */
|
|
620
819
|
/* Excluded from this release type: _onSceneLoaded */
|
|
621
820
|
delete(stream: Stream): void;
|
|
622
821
|
close(): void;
|
|
@@ -640,12 +839,117 @@ declare interface SceneMetadata extends EmbindObject {
|
|
|
640
839
|
readonly inputColorSpace: string;
|
|
641
840
|
}
|
|
642
841
|
|
|
643
|
-
declare
|
|
644
|
-
|
|
645
|
-
|
|
646
|
-
|
|
842
|
+
declare interface SharkInfo {
|
|
843
|
+
renderCalls: number;
|
|
844
|
+
render: SharkRenderInfo;
|
|
845
|
+
reset(): void;
|
|
846
|
+
}
|
|
847
|
+
|
|
848
|
+
declare interface SharkModule {
|
|
849
|
+
Camera: new () => Camera_2;
|
|
850
|
+
RenderState: new () => RenderState;
|
|
851
|
+
SplatSet: new () => SplatSet;
|
|
852
|
+
GlassMeshRegistry: new () => GlassMeshRegistry;
|
|
853
|
+
vec4: new (x: number, y: number, z: number, w: number) => vec4;
|
|
854
|
+
|
|
855
|
+
SortType: {
|
|
856
|
+
RADIX_SORT: SortTypeValue;
|
|
857
|
+
OCTREE_SORT: SortTypeValue;
|
|
858
|
+
KDTREE_SORT: SortTypeValue;
|
|
859
|
+
STD_SORT: SortTypeValue;
|
|
860
|
+
};
|
|
861
|
+
|
|
862
|
+
TextureFormat: {
|
|
863
|
+
RGBA32_Float: TextureFormatValue;
|
|
864
|
+
RGBA16_Float: TextureFormatValue;
|
|
865
|
+
RG16_Float: TextureFormatValue;
|
|
866
|
+
RGBA32_UInt: TextureFormatValue;
|
|
867
|
+
RGBA32_SInt: TextureFormatValue;
|
|
868
|
+
RGBA16_UInt: TextureFormatValue;
|
|
869
|
+
RGBA16_SInt: TextureFormatValue;
|
|
870
|
+
RGBA8_UInt: TextureFormatValue;
|
|
871
|
+
RGBA8_SInt: TextureFormatValue;
|
|
872
|
+
RGBA8_UNorm: TextureFormatValue;
|
|
873
|
+
RGBA8_SNorm: TextureFormatValue;
|
|
874
|
+
RGBA16_UNorm: TextureFormatValue;
|
|
875
|
+
RGBA16_SNorm: TextureFormatValue;
|
|
876
|
+
BGRA8_UNorm: TextureFormatValue;
|
|
877
|
+
BC6HRGB_UFloat: TextureFormatValue;
|
|
878
|
+
BC6HRGB_Float: TextureFormatValue;
|
|
879
|
+
BC7RGBA_UNorm: TextureFormatValue;
|
|
880
|
+
BC7RGBA_UNormSrgb: TextureFormatValue;
|
|
881
|
+
BC3RGBA_UNorm: TextureFormatValue;
|
|
882
|
+
BC3RGBA_UNormSrgb: TextureFormatValue;
|
|
883
|
+
Depth16Unorm: TextureFormatValue;
|
|
884
|
+
Depth24Plus: TextureFormatValue;
|
|
885
|
+
Depth32Float: TextureFormatValue;
|
|
886
|
+
};
|
|
887
|
+
|
|
888
|
+
WebGPU: WebGPUInterface;
|
|
889
|
+
|
|
890
|
+
// HEAPU8 is replaced whenever the heap grows, so read it fresh rather than caching it.
|
|
891
|
+
_malloc(byteCount: number): number;
|
|
892
|
+
_free(ptr: number): void;
|
|
893
|
+
readonly HEAPU8: Uint8Array;
|
|
894
|
+
|
|
895
|
+
uploadSplatSetData(
|
|
896
|
+
set: SplatSet,
|
|
897
|
+
renderState: RenderState,
|
|
898
|
+
start: number,
|
|
899
|
+
): void;
|
|
900
|
+
uploadChunkFades(set: SplatSet, renderState: RenderState): void;
|
|
901
|
+
// One mat4 per model root, so cheap enough to call every frame while an asset is moving
|
|
902
|
+
uploadModelRootTransforms(set: SplatSet, renderState: RenderState): void;
|
|
903
|
+
processSplatSet(
|
|
904
|
+
camera: Camera_2,
|
|
905
|
+
set: SplatSet,
|
|
906
|
+
renderState: RenderState,
|
|
907
|
+
width: number,
|
|
908
|
+
height: number,
|
|
909
|
+
triangles: number,
|
|
910
|
+
projectOnGPU: boolean,
|
|
911
|
+
cullEllipsoid: boolean,
|
|
912
|
+
useAffineApprox: boolean,
|
|
913
|
+
depthSortOnGPU: boolean,
|
|
914
|
+
useInvZ: boolean,
|
|
915
|
+
rasterizeWithCompute: boolean,
|
|
916
|
+
useSOGS: boolean,
|
|
917
|
+
sortType: SortTypeValue,
|
|
918
|
+
skipSort: boolean,
|
|
919
|
+
): number;
|
|
920
|
+
createRendererWGPUWithoutSurface(
|
|
921
|
+
colorTargetFormat: TextureFormatValue,
|
|
922
|
+
): RendererWGPU;
|
|
923
|
+
/// Gives back the reference WebGPU.importJsTexture returned for a texture.
|
|
924
|
+
releaseImportedTexture(texture: number): void;
|
|
925
|
+
renderSplatSetToSceneTextures(
|
|
926
|
+
splatSet: SplatSet,
|
|
927
|
+
renderState: RenderState,
|
|
928
|
+
colorTarget: number,
|
|
929
|
+
depthTarget: number,
|
|
930
|
+
renderGES: boolean,
|
|
931
|
+
): void;
|
|
932
|
+
// Render view registry, indexed as RenderViews.h orders it. setRenderView ignores an index
|
|
933
|
+
// Shark cannot produce.
|
|
934
|
+
setRenderView(viewIndex: number): void;
|
|
935
|
+
renderView(): number;
|
|
936
|
+
renderViewCount(): number;
|
|
937
|
+
renderViewName(viewIndex: number): string;
|
|
938
|
+
renderViewSupported(viewIndex: number): boolean;
|
|
939
|
+
// The next supported view, forwards for direction 1 and backwards for -1.
|
|
940
|
+
stepRenderView(from: number, direction: number): number;
|
|
941
|
+
}
|
|
942
|
+
|
|
943
|
+
declare interface SharkRenderInfo {
|
|
944
|
+
triangles: number;
|
|
945
|
+
}
|
|
946
|
+
|
|
947
|
+
declare interface SortTypeValue {
|
|
948
|
+
value: number;
|
|
949
|
+
}
|
|
647
950
|
|
|
648
|
-
|
|
951
|
+
/** @deprecated Use clientAttributeList. */
|
|
952
|
+
export declare const sparkAttributeList: Record<string, ClientAttributeInfo>;
|
|
649
953
|
|
|
650
954
|
declare interface SpatialFormat extends EmbindObject {
|
|
651
955
|
metersPerUnit: number;
|
|
@@ -654,6 +958,86 @@ declare interface SpatialFormat extends EmbindObject {
|
|
|
654
958
|
handedness: number;
|
|
655
959
|
}
|
|
656
960
|
|
|
961
|
+
declare interface SplatSet {
|
|
962
|
+
splatCount: number;
|
|
963
|
+
// Number of splats actually drawn: ordering[0, activeSplats) holds the unmasked splat indices.
|
|
964
|
+
// Set alongside orderingView() to restrict the draw to unmasked octant ranges.
|
|
965
|
+
activeSplats: number;
|
|
966
|
+
// Selects which ellipsoid layout to allocate and what ellipsoidsView() exposes:
|
|
967
|
+
// packed (16 bytes/splat) or uncompressed (48). Must be set before the first resize.
|
|
968
|
+
usePackedEllipsoids: boolean;
|
|
969
|
+
// direct-write upload: resize -> write into the views -> finalize.
|
|
970
|
+
// views are valid only until the next resize.
|
|
971
|
+
resize(splatCount: number): void;
|
|
972
|
+
ellipsoidsView(): Uint32Array;
|
|
973
|
+
colorsView(): Uint32Array;
|
|
974
|
+
sh1View(): Uint32Array;
|
|
975
|
+
sh2View(): Uint32Array;
|
|
976
|
+
sh3aView(): Uint32Array;
|
|
977
|
+
sh3bView(): Uint32Array;
|
|
978
|
+
// mod_depth is a half-float per primitive slot (dense, padded for non-surfels), so this is a
|
|
979
|
+
// Uint16Array unlike every other view here -- do not address it with the uint32 splat strides
|
|
980
|
+
// used for ellipsoids/colors/sh*.
|
|
981
|
+
modDepthView(): Uint16Array;
|
|
982
|
+
// Per-chunk fade (opacity multiplier), one float per chunk, defaults to 1.0.
|
|
983
|
+
// Also sizes the chunk slot to model root slot map below, since both are indexed by chunk slot
|
|
984
|
+
resizeChunkFades(chunkCount: number): void;
|
|
985
|
+
chunkFadesView(): Float32Array;
|
|
986
|
+
// Per-splat chunk index, defaults to slot 0. Write before finalize()
|
|
987
|
+
chunkIndicesView(): Int32Array;
|
|
988
|
+
// Model transforms, resolved per splat as
|
|
989
|
+
// modelRootTransforms[chunkModelRoots[chunkIndices[splat]]]
|
|
990
|
+
// Slot 0 of both tables is reserved as identity, so real slots start at 1 and a set that
|
|
991
|
+
// never writes them renders untransformed.
|
|
992
|
+
resizeModelRootSlots(modelRootCount: number): void;
|
|
993
|
+
// 16 floats per model root, COLUMN-major - i.e. write THREE's Matrix4.toArray() straight in
|
|
994
|
+
modelRootTransformsView(): Float32Array;
|
|
995
|
+
// The inverses, same slots and layout. The true-perspective projection (Project.glsl) transforms
|
|
996
|
+
// a quadratic form and needs them; writing a transform without its inverse leaves that path
|
|
997
|
+
// projecting the splat as if untransformed. Use Matrix4.invert() on a copy
|
|
998
|
+
modelRootInverseTransformsView(): Float32Array;
|
|
999
|
+
// Sized by resizeChunkFades. Defaults to slot 0 (identity) for every chunk
|
|
1000
|
+
chunkModelRootsView(): Int32Array;
|
|
1001
|
+
// resizeModelRootSlots resets every slot to the absolute decode. False for a slot outside the table
|
|
1002
|
+
setModelRootRootRelativeDecode(
|
|
1003
|
+
slot: number,
|
|
1004
|
+
originX: number,
|
|
1005
|
+
originY: number,
|
|
1006
|
+
originZ: number,
|
|
1007
|
+
step: number,
|
|
1008
|
+
lnScaleOffset: number,
|
|
1009
|
+
): boolean;
|
|
1010
|
+
// int32 render-order buffer (sized 2*splatCount after finalize). Valid only until the next resize.
|
|
1011
|
+
orderingView(): Int32Array;
|
|
1012
|
+
finalize(): void;
|
|
1013
|
+
// like finalize() but keeps splats in their delivered (octant-sorted) order — no kd-tree reorder —
|
|
1014
|
+
// so sparse-octant range masking can index child-octant ranges directly. RADIX_SORT only.
|
|
1015
|
+
finalizeBounds(): void;
|
|
1016
|
+
// Whether the asset carries per-surfel reflectance records, which is what decides whether
|
|
1017
|
+
// reflections are shaded at all. Pass to RenderState.uploadReflectionLadderParams.
|
|
1018
|
+
hasReflectionParams(): boolean;
|
|
1019
|
+
// Widens packed reflectance records - recordVersion 2 for 18-byte reflectanceDataV2, 1 for
|
|
1020
|
+
// 26-byte reflectanceDataV1 - into the per-splat GPU records at bufferOffset. wirePtr must
|
|
1021
|
+
// address THIS module's heap - _malloc here and copy the bytes in, since the attribute lives in
|
|
1022
|
+
// the engine module's. Records cover a node's surfel range, which starts at its first splat.
|
|
1023
|
+
// Returns the records written; 0 if the data was rejected.
|
|
1024
|
+
decodeReflectionParams(
|
|
1025
|
+
recordVersion: number,
|
|
1026
|
+
wirePtr: number,
|
|
1027
|
+
wireSizeBytes: number,
|
|
1028
|
+
elementCount: number,
|
|
1029
|
+
bufferOffset: number,
|
|
1030
|
+
nodeSplatCount: number,
|
|
1031
|
+
logId: number,
|
|
1032
|
+
): number;
|
|
1033
|
+
// Zeroes records in [startSplat, endSplat). Needed wherever splats are re-packed at fresh
|
|
1034
|
+
// offsets, or a reused slot shades its splat from the previous occupant's material.
|
|
1035
|
+
clearReflectionParams(startSplat: number, endSplat: number): void;
|
|
1036
|
+
// Splats in [0, count) holding a non-zero record. Diagnostic.
|
|
1037
|
+
populatedReflectionParamCount(count: number): number;
|
|
1038
|
+
delete(): void;
|
|
1039
|
+
}
|
|
1040
|
+
|
|
657
1041
|
export declare class Stream extends EventTarget {
|
|
658
1042
|
#private;
|
|
659
1043
|
static readonly _idMap: Map<number, Stream>;
|
|
@@ -676,6 +1060,9 @@ export declare class Stream extends EventTarget {
|
|
|
676
1060
|
set matrix(matrix: Matrix4x4Tuple);
|
|
677
1061
|
get opacity(): number;
|
|
678
1062
|
set opacity(opacity: number);
|
|
1063
|
+
get fetchMode(): StreamFetchMode;
|
|
1064
|
+
set fetchMode(fetchMode: StreamFetchMode);
|
|
1065
|
+
/* Excluded from this release type: _applyFetchMode */
|
|
679
1066
|
get boundingBox(): {
|
|
680
1067
|
min: {
|
|
681
1068
|
x: number;
|
|
@@ -708,11 +1095,23 @@ export declare class Stream extends EventTarget {
|
|
|
708
1095
|
/* Excluded from this release type: _onStreamLoaded */
|
|
709
1096
|
getDefaultCameraTransform(): Float32Array<ArrayBuffer> | null | undefined;
|
|
710
1097
|
/* Excluded from this release type: _getViewingVolumeObb */
|
|
1098
|
+
/** How much of the stream has loaded, as of the last frame. */
|
|
1099
|
+
get readyState(): ReadyState_2;
|
|
1100
|
+
/* Excluded from this release type: _updateStatus */
|
|
711
1101
|
/* Excluded from this release type: _onRootLoaded */
|
|
712
1102
|
add(modelRoot: ModelRoot): void;
|
|
713
1103
|
end(): void;
|
|
714
1104
|
}
|
|
715
1105
|
|
|
1106
|
+
/**
|
|
1107
|
+
* What the engine will do with stream data: "regular" fetches and draws what the
|
|
1108
|
+
* camera needs. "prefetch" keeps fetching for the camera into the cache but does not change what is drawn.
|
|
1109
|
+
* "parked" fetches nothing and draws nothing, giving its share of the splat budget and
|
|
1110
|
+
* renderer to the other streams; what it already loaded stays cached on the cpu side for when it is unparked.
|
|
1111
|
+
* You may want to park streams while making them invisible.
|
|
1112
|
+
*/
|
|
1113
|
+
export declare type StreamFetchMode = "regular" | "prefetch" | "parked";
|
|
1114
|
+
|
|
716
1115
|
export declare type StreamInit = {
|
|
717
1116
|
uuid: string;
|
|
718
1117
|
scene: Scene;
|
|
@@ -722,6 +1121,10 @@ export declare type StreamInit = {
|
|
|
722
1121
|
|
|
723
1122
|
declare type StringVector = EmbindVector<string>;
|
|
724
1123
|
|
|
1124
|
+
declare interface TextureFormatValue {
|
|
1125
|
+
value: number;
|
|
1126
|
+
}
|
|
1127
|
+
|
|
725
1128
|
/** Recursive variant tree node from WASM. */
|
|
726
1129
|
export declare type VariantNode = {
|
|
727
1130
|
id: number;
|
|
@@ -732,4 +1135,18 @@ export declare type VariantNode = {
|
|
|
732
1135
|
nestedSets?: VariantNode[];
|
|
733
1136
|
};
|
|
734
1137
|
|
|
1138
|
+
declare interface vec4 {
|
|
1139
|
+
x: number;
|
|
1140
|
+
y: number;
|
|
1141
|
+
z: number;
|
|
1142
|
+
w: number;
|
|
1143
|
+
delete(): void;
|
|
1144
|
+
}
|
|
1145
|
+
|
|
1146
|
+
declare interface WebGPUInterface {
|
|
1147
|
+
importJsAdapter(adapter: GPUAdapter, parentPtr?: number): number;
|
|
1148
|
+
importJsDevice(device: GPUDevice, parentPtr?: number): number;
|
|
1149
|
+
importJsTexture(obj: GPUTexture, parentPtr?: number): number;
|
|
1150
|
+
}
|
|
1151
|
+
|
|
735
1152
|
export { }
|