@3dverse/livelink.core 1.1.11 → 1.1.13
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/_prebuild/engine_types/ComponentsRecord.d.ts +44 -44
- package/dist/_prebuild/engine_types/SceneSettingsRecord.d.ts +18 -12
- package/dist/_prebuild/engine_types/assets.d.ts +0 -4
- package/dist/_prebuild/engine_types/components.d.ts +228 -228
- package/dist/_prebuild/engine_types/sceneSettings.d.ts +46 -46
- package/dist/_prebuild/messages/editor/SceneSettingsUpdatedEvent.d.ts +1 -0
- package/dist/_prebuild/messages/editor/index.d.ts +1 -0
- package/dist/library.cjs +1 -1
- package/dist/library.mjs +1 -1
- package/dist/sources/CoreEvents.d.ts +2 -1
- package/dist/sources/LivelinkCore.d.ts +2 -2
- package/dist/sources/core.d.ts +2 -0
- package/dist/sources/internal/EditorEvents.d.ts +11 -5
- package/package.json +1 -1
|
@@ -18,80 +18,80 @@ export type Euid = {
|
|
|
18
18
|
rtid: RTID;
|
|
19
19
|
};
|
|
20
20
|
/**
|
|
21
|
-
*
|
|
21
|
+
* Drives skeletal animation using an Animation Graph and Animation Set; animates descendant skinned meshes whose skeletons are compatible with the set.
|
|
22
22
|
*/
|
|
23
23
|
export type AnimationController = {
|
|
24
24
|
/**
|
|
25
|
-
*
|
|
25
|
+
* Referenced Animation Graph (UUID).
|
|
26
26
|
*/
|
|
27
27
|
animationGraphRef: AssetRef<Assets.AnimationGraph>;
|
|
28
28
|
/**
|
|
29
|
-
*
|
|
29
|
+
* Referenced Animation Set (UUID).
|
|
30
30
|
*/
|
|
31
31
|
animationSetRef: AssetRef<Assets.AnimationSet>;
|
|
32
32
|
/**
|
|
33
|
-
*
|
|
33
|
+
* Animation Graph input parameters in JSON format.
|
|
34
34
|
*/
|
|
35
35
|
dataJSON: AnimationGraphDataObject;
|
|
36
36
|
/**
|
|
37
|
-
*
|
|
37
|
+
* Entity containing the Bone component for the skeleton's root bone.
|
|
38
38
|
*/
|
|
39
39
|
rootBoneEntityRef: EntityRef;
|
|
40
40
|
/**
|
|
41
|
-
*
|
|
41
|
+
* Enable root motion extraction and application to the entity transform.
|
|
42
42
|
* @defaultValue false
|
|
43
43
|
*/
|
|
44
44
|
rootMotionEnabled: boolean;
|
|
45
45
|
};
|
|
46
46
|
/**
|
|
47
|
-
*
|
|
47
|
+
* Controls playback of an Animation Sequence; assigns tracks to entities.
|
|
48
48
|
*/
|
|
49
49
|
export type AnimationSequenceController = {
|
|
50
50
|
/**
|
|
51
|
-
*
|
|
51
|
+
* Referenced Animation Sequence (UUID).
|
|
52
52
|
*/
|
|
53
53
|
animationSequenceRef: AssetRef<Assets.AnimationSequence>;
|
|
54
54
|
/**
|
|
55
|
-
*
|
|
55
|
+
* Map from track UUID to assigned entity.
|
|
56
56
|
*/
|
|
57
57
|
entities: Record<UUID, EntityRef>;
|
|
58
58
|
/**
|
|
59
|
-
*
|
|
59
|
+
* Playback speed multiplier. Negative values play in reverse.
|
|
60
60
|
* @defaultValue 1
|
|
61
61
|
*/
|
|
62
62
|
playbackSpeed: Float;
|
|
63
63
|
/**
|
|
64
|
-
*
|
|
64
|
+
* Normalized start offset [0, 1].
|
|
65
65
|
* @defaultValue 0
|
|
66
66
|
*/
|
|
67
67
|
startOffset: Float;
|
|
68
68
|
/**
|
|
69
|
-
*
|
|
69
|
+
* Normalized stop offset [0, 1]. When looping, playback wraps to startOffset at this point.
|
|
70
70
|
* @defaultValue 1
|
|
71
71
|
*/
|
|
72
72
|
stopOffset: Float;
|
|
73
73
|
/**
|
|
74
|
-
*
|
|
74
|
+
* Loop playback when reaching the stop offset.
|
|
75
75
|
* @defaultValue false
|
|
76
76
|
*/
|
|
77
77
|
loop: boolean;
|
|
78
78
|
/**
|
|
79
|
-
*
|
|
79
|
+
* Current playback state.
|
|
80
80
|
* @defaultValue 0
|
|
81
81
|
*/
|
|
82
82
|
playState: UInt8;
|
|
83
83
|
/**
|
|
84
|
-
*
|
|
84
|
+
* Normalized offset [0, 1] to seek on the next frame; set to -1 to ignore.
|
|
85
85
|
* @defaultValue -1
|
|
86
86
|
*/
|
|
87
87
|
seekOffset: Float;
|
|
88
88
|
};
|
|
89
89
|
/**
|
|
90
|
-
*
|
|
90
|
+
* Associates this entity with a bone in a skeleton (for attachments and transforms).
|
|
91
91
|
*/
|
|
92
92
|
export type Bone = {
|
|
93
93
|
/**
|
|
94
|
-
*
|
|
94
|
+
* Zero-based index of this bone within the bound skeleton.
|
|
95
95
|
*/
|
|
96
96
|
boneIndex: UInt32;
|
|
97
97
|
};
|
|
@@ -100,12 +100,12 @@ export type Bone = {
|
|
|
100
100
|
*/
|
|
101
101
|
export type BoxGeometry = {
|
|
102
102
|
/**
|
|
103
|
-
*
|
|
103
|
+
* Box dimensions (width, height, depth) in meters.
|
|
104
104
|
* @defaultValue 1,1,1
|
|
105
105
|
*/
|
|
106
106
|
dimension: Vec3;
|
|
107
107
|
/**
|
|
108
|
-
*
|
|
108
|
+
* Local offset of the geometry origin (meters).
|
|
109
109
|
* @defaultValue 0,0,0
|
|
110
110
|
*/
|
|
111
111
|
offset: Vec3;
|
|
@@ -115,16 +115,16 @@ export type BoxGeometry = {
|
|
|
115
115
|
*/
|
|
116
116
|
export type Camera = {
|
|
117
117
|
/**
|
|
118
|
-
*
|
|
118
|
+
* Referenced render graph to use for rendering from this camera.
|
|
119
119
|
*/
|
|
120
120
|
renderGraphRef: AssetRef<Assets.RenderGraph>;
|
|
121
121
|
/**
|
|
122
|
-
* Index of the render target to blit.
|
|
122
|
+
* Index of the render target to blit/output to. -1 indicates the default target.
|
|
123
123
|
* @defaultValue -1
|
|
124
124
|
*/
|
|
125
125
|
renderTargetIndex: Int32;
|
|
126
126
|
/**
|
|
127
|
-
*
|
|
127
|
+
* Render Graph input parameters in JSON; schema defined by renderGraphRef.
|
|
128
128
|
*/
|
|
129
129
|
dataJSON: RenderGraphDataObject;
|
|
130
130
|
};
|
|
@@ -133,217 +133,226 @@ export type Camera = {
|
|
|
133
133
|
*/
|
|
134
134
|
export type CapsuleGeometry = {
|
|
135
135
|
/**
|
|
136
|
-
* Radius of the
|
|
136
|
+
* Radius of the hemispherical ends (meters).
|
|
137
137
|
* @defaultValue 0.5
|
|
138
138
|
*/
|
|
139
139
|
radius: Float;
|
|
140
140
|
/**
|
|
141
|
-
* Height of the cylindrical
|
|
141
|
+
* Height of the cylindrical mid-section (meters).
|
|
142
142
|
* @defaultValue 1
|
|
143
143
|
*/
|
|
144
144
|
height: Float;
|
|
145
145
|
/**
|
|
146
|
-
* Alignment axis
|
|
146
|
+
* Alignment axis of the capsule: 0=X, 1=Y, 2=Z.
|
|
147
147
|
* @defaultValue 1
|
|
148
148
|
*/
|
|
149
149
|
axis: Int32;
|
|
150
150
|
/**
|
|
151
|
-
*
|
|
151
|
+
* Local offset of the geometry origin (meters).
|
|
152
152
|
* @defaultValue 0,0,0
|
|
153
153
|
*/
|
|
154
154
|
offset: Vec3;
|
|
155
155
|
};
|
|
156
156
|
/**
|
|
157
|
-
*
|
|
157
|
+
* Kinematic character controller for collision-constrained movement without a rigid body. Uses tuned collision handling for responsive control.
|
|
158
158
|
*/
|
|
159
159
|
export type CharacterController = {
|
|
160
160
|
/**
|
|
161
|
-
*
|
|
161
|
+
* Maximum climbable step height. Steps higher than this cannot be climbed automatically.
|
|
162
162
|
* @defaultValue 0
|
|
163
163
|
*/
|
|
164
164
|
stepOffset: Float;
|
|
165
165
|
/**
|
|
166
|
-
*
|
|
166
|
+
* Maximum walkable slope (degrees). Slopes steeper than this are not walkable.
|
|
167
167
|
* @defaultValue 45
|
|
168
168
|
*/
|
|
169
169
|
slopeLimit: Float;
|
|
170
170
|
/**
|
|
171
|
-
*
|
|
171
|
+
* Collision skin width (meters).
|
|
172
172
|
* @defaultValue 0
|
|
173
173
|
*/
|
|
174
174
|
skinWidth: Float;
|
|
175
175
|
/**
|
|
176
|
-
*
|
|
176
|
+
* Requested displacement for the current frame.
|
|
177
177
|
* @defaultValue 0,0,0
|
|
178
178
|
*/
|
|
179
179
|
displacement: Vec3;
|
|
180
180
|
};
|
|
181
181
|
/**
|
|
182
|
-
* Reference to a collision geometry.
|
|
182
|
+
* Reference to a collision geometry asset used by physics.
|
|
183
183
|
*/
|
|
184
184
|
export type CollisionGeometryRef = {
|
|
185
185
|
/**
|
|
186
|
-
*
|
|
186
|
+
* Referenced collision geometry (UUID).
|
|
187
187
|
*/
|
|
188
188
|
collisionGeometryRef: AssetRef<Assets.CollisionGeometry>;
|
|
189
189
|
};
|
|
190
190
|
/**
|
|
191
|
-
*
|
|
191
|
+
* 6-DoF constraint built on a Joint. Defaults to fixed; selectively unlock translation and rotation on X/Y/Z and configure limits and springs.
|
|
192
192
|
*/
|
|
193
193
|
export type Constraint = {
|
|
194
194
|
/**
|
|
195
|
-
* Unlock motion along/around the specified
|
|
195
|
+
* Unlock motion along/around the specified axes.
|
|
196
196
|
* @defaultValue 0
|
|
197
197
|
*/
|
|
198
198
|
unlockedMotion: UInt32;
|
|
199
199
|
/**
|
|
200
|
-
*
|
|
200
|
+
* Lower linear limit per axis (meters).
|
|
201
201
|
* @defaultValue 0,0,0
|
|
202
202
|
*/
|
|
203
203
|
motionLowerLimit: Vec3;
|
|
204
204
|
/**
|
|
205
|
-
*
|
|
205
|
+
* Upper linear limit per axis (meters).
|
|
206
206
|
* @defaultValue 0,0,0
|
|
207
207
|
*/
|
|
208
208
|
motionUpperLimit: Vec3;
|
|
209
209
|
/**
|
|
210
|
-
*
|
|
210
|
+
* Linear limit spring stiffness per axis (N/m). >0 makes the limit soft (spring-like).
|
|
211
211
|
* @defaultValue 0,0,0
|
|
212
212
|
*/
|
|
213
213
|
motionLimitSpringStiffness: Vec3;
|
|
214
214
|
/**
|
|
215
|
-
*
|
|
215
|
+
* Linear limit spring damping per axis (N·s/m).
|
|
216
216
|
* @defaultValue 0,0,0
|
|
217
217
|
*/
|
|
218
218
|
motionLimitSpringDamping: Vec3;
|
|
219
219
|
/**
|
|
220
|
-
*
|
|
220
|
+
* Swing cone half-angles about Y and Z of the constraint frame (degrees). 0 does not restrict rotation; max 180. Used if either swing axis is limited.
|
|
221
221
|
* @defaultValue 0,0
|
|
222
222
|
*/
|
|
223
223
|
swingLimitAngle: Vec2;
|
|
224
224
|
/**
|
|
225
|
-
*
|
|
225
|
+
* Swing limit spring stiffness (N·m/rad). >0 makes the limit soft.
|
|
226
226
|
* @defaultValue 0
|
|
227
227
|
*/
|
|
228
228
|
swingSpringStiffness: Float;
|
|
229
229
|
/**
|
|
230
|
-
*
|
|
230
|
+
* Swing limit spring damping (N·m·s/rad).
|
|
231
231
|
* @defaultValue 0
|
|
232
232
|
*/
|
|
233
233
|
swingSpringDamping: Float;
|
|
234
234
|
/**
|
|
235
|
-
*
|
|
235
|
+
* Twist angle limits (min,max) around the twist axis (degrees). Range (−360, 360).
|
|
236
236
|
* @defaultValue 0,0
|
|
237
237
|
*/
|
|
238
238
|
twistLimitAngle: Vec2;
|
|
239
239
|
/**
|
|
240
|
-
*
|
|
240
|
+
* Twist limit spring stiffness (N·m/rad). >0 makes the limit soft.
|
|
241
241
|
* @defaultValue 0
|
|
242
242
|
*/
|
|
243
243
|
twistSpringStiffness: Float;
|
|
244
244
|
/**
|
|
245
|
-
*
|
|
245
|
+
* Twist limit spring damping (N·m·s/rad).
|
|
246
246
|
* @defaultValue 0
|
|
247
247
|
*/
|
|
248
248
|
twistSpringDamping: Float;
|
|
249
249
|
};
|
|
250
250
|
/**
|
|
251
|
-
*
|
|
251
|
+
* Drives a Constraint toward target position/orientation and velocities using configurable stiffness, damping, and force limits.
|
|
252
252
|
*/
|
|
253
253
|
export type ConstraintActuator = {
|
|
254
254
|
/**
|
|
255
|
-
*
|
|
255
|
+
* Linear drive stiffness per axis (N/m). >0 applies spring force toward the goal.
|
|
256
256
|
* @defaultValue 0,0,0
|
|
257
257
|
*/
|
|
258
258
|
linearStiffness: Vec3;
|
|
259
259
|
/**
|
|
260
|
-
*
|
|
260
|
+
* Linear drive damping per axis (N·s/m).
|
|
261
261
|
* @defaultValue 0,0,0
|
|
262
262
|
*/
|
|
263
263
|
linearDamping: Vec3;
|
|
264
264
|
/**
|
|
265
|
-
*
|
|
265
|
+
* Max linear drive force/impulse per axis (N). −1 = unlimited.
|
|
266
266
|
* @defaultValue -1,-1,-1
|
|
267
267
|
*/
|
|
268
268
|
linearForceLimit: Vec3;
|
|
269
269
|
/**
|
|
270
|
-
*
|
|
270
|
+
* Angular drive stiffness per axis (N·m/rad). >0 applies spring torque toward the goal.
|
|
271
271
|
* @defaultValue 0,0,0
|
|
272
272
|
*/
|
|
273
273
|
angularStiffness: Vec3;
|
|
274
274
|
/**
|
|
275
|
-
*
|
|
275
|
+
* Angular drive damping per axis (N·m·s/rad).
|
|
276
276
|
* @defaultValue 0,0,0
|
|
277
277
|
*/
|
|
278
278
|
angularDamping: Vec3;
|
|
279
279
|
/**
|
|
280
|
-
*
|
|
280
|
+
* Max angular drive torque/impulse per axis (N·m). −1 = unlimited.
|
|
281
281
|
* @defaultValue -1,-1,-1
|
|
282
282
|
*/
|
|
283
283
|
angularForceLimit: Vec3;
|
|
284
284
|
/**
|
|
285
|
-
*
|
|
285
|
+
* Drive type: apply as force or as acceleration.
|
|
286
286
|
* @defaultValue 1
|
|
287
287
|
*/
|
|
288
288
|
type: Int32;
|
|
289
289
|
/**
|
|
290
|
-
*
|
|
290
|
+
* Target linear position offset (meters).
|
|
291
291
|
* @defaultValue 0,0,0
|
|
292
292
|
*/
|
|
293
293
|
goalPosition: Vec3;
|
|
294
294
|
/**
|
|
295
|
-
*
|
|
295
|
+
* Target angular orientation.
|
|
296
296
|
* @defaultValue 0,0,0,1
|
|
297
297
|
*/
|
|
298
298
|
goalOrientation: Quat;
|
|
299
299
|
/**
|
|
300
|
-
*
|
|
300
|
+
* Target linear velocity (m/s).
|
|
301
301
|
* @defaultValue 0,0,0
|
|
302
302
|
*/
|
|
303
303
|
linearVelocity: Vec3;
|
|
304
304
|
/**
|
|
305
|
-
*
|
|
305
|
+
* Target angular velocity (rad/s).
|
|
306
306
|
* @defaultValue 0,0,0
|
|
307
307
|
*/
|
|
308
308
|
angularVelocity: Vec3;
|
|
309
309
|
};
|
|
310
310
|
/**
|
|
311
|
-
*
|
|
311
|
+
* Enables culling using a simple analytic shape. Add alongside a geometry component (box, cylinder, plane, sphere).
|
|
312
312
|
*/
|
|
313
313
|
export type CullingGeometry = {
|
|
314
314
|
/**
|
|
315
|
-
* Additive
|
|
315
|
+
* Additive: show elements inside the geometry. Subtractive: show elements outside the geometry.
|
|
316
316
|
* @defaultValue true
|
|
317
317
|
*/
|
|
318
318
|
isAdditive: boolean;
|
|
319
319
|
};
|
|
320
|
+
/**
|
|
321
|
+
* Custom projection lens using an explicit projection matrix.
|
|
322
|
+
*/
|
|
323
|
+
export type CustomLens = {
|
|
324
|
+
/**
|
|
325
|
+
* Projection matrix mapping view-space to clip-space (cs_from_vs).
|
|
326
|
+
*/
|
|
327
|
+
cs_from_vs: Mat4;
|
|
328
|
+
};
|
|
320
329
|
/**
|
|
321
330
|
* Cylinder geometry.
|
|
322
331
|
*/
|
|
323
332
|
export type CylinderGeometry = {
|
|
324
333
|
/**
|
|
325
|
-
* Radius of the cylinder.
|
|
334
|
+
* Radius of the cylinder (meters).
|
|
326
335
|
* @defaultValue 0.5
|
|
327
336
|
*/
|
|
328
337
|
radius: Float;
|
|
329
338
|
/**
|
|
330
|
-
* Height of the cylinder.
|
|
339
|
+
* Height of the cylinder (meters).
|
|
331
340
|
* @defaultValue 1
|
|
332
341
|
*/
|
|
333
342
|
height: Float;
|
|
334
343
|
/**
|
|
335
|
-
* Alignment axis
|
|
344
|
+
* Alignment axis of the cylinder: 0=X, 1=Y, 2=Z.
|
|
336
345
|
* @defaultValue 1
|
|
337
346
|
*/
|
|
338
347
|
axis: Int32;
|
|
339
348
|
/**
|
|
340
|
-
*
|
|
349
|
+
* Local offset of the geometry origin (meters).
|
|
341
350
|
* @defaultValue 0,0,0
|
|
342
351
|
*/
|
|
343
352
|
offset: Vec3;
|
|
344
353
|
};
|
|
345
354
|
/**
|
|
346
|
-
*
|
|
355
|
+
* Human-readable name of the entity.
|
|
347
356
|
*/
|
|
348
357
|
export type DebugName = {
|
|
349
358
|
/**
|
|
@@ -352,210 +361,210 @@ export type DebugName = {
|
|
|
352
361
|
value: string;
|
|
353
362
|
};
|
|
354
363
|
/**
|
|
355
|
-
*
|
|
364
|
+
* Projects a material onto scene surfaces within the projector's box volume.
|
|
356
365
|
*/
|
|
357
366
|
export type DecalProjector = {
|
|
358
367
|
/**
|
|
359
|
-
* Z-
|
|
368
|
+
* Z-index ordering for decal rendering; higher values render on top of lower ones.
|
|
360
369
|
* @defaultValue 0
|
|
361
370
|
*/
|
|
362
371
|
zIndex: Int32;
|
|
363
372
|
};
|
|
364
373
|
/**
|
|
365
|
-
*
|
|
374
|
+
* Scene environment settings, including skybox background and precomputed image-based lighting (IBL). This component is only applied in the scene where this entity lives, it is discarded for subscenes.
|
|
366
375
|
*/
|
|
367
376
|
export type Environment = {
|
|
368
377
|
/**
|
|
369
|
-
*
|
|
378
|
+
* Skybox cubemap used as the scene background (no lighting effect).
|
|
370
379
|
*/
|
|
371
380
|
skyboxUUID: AssetRef<Assets.Cubemap>;
|
|
372
381
|
/**
|
|
373
|
-
*
|
|
382
|
+
* Specular radiance cubemap (prefiltered) used for PBR reflections.
|
|
374
383
|
*/
|
|
375
384
|
radianceUUID: AssetRef<Assets.Cubemap>;
|
|
376
385
|
/**
|
|
377
|
-
*
|
|
386
|
+
* Diffuse irradiance cubemap used for ambient PBR lighting.
|
|
378
387
|
*/
|
|
379
388
|
irradianceUUID: AssetRef<Assets.Cubemap>;
|
|
380
389
|
};
|
|
381
390
|
/**
|
|
382
|
-
* Base
|
|
391
|
+
* Base joint connecting two bodies. By default locks relative position and orientation between constrainer and constrainee.
|
|
383
392
|
*/
|
|
384
393
|
export type Joint = {
|
|
385
394
|
/**
|
|
386
|
-
*
|
|
395
|
+
* Entity with a Rigid Body to be constrained.
|
|
387
396
|
*/
|
|
388
397
|
constrainee: EntityRef;
|
|
389
398
|
/**
|
|
390
|
-
*
|
|
399
|
+
* Entity acting as constrainer (rigid/static) or null to constrain to world origin.
|
|
391
400
|
*/
|
|
392
401
|
constrainer: EntityRef;
|
|
393
402
|
/**
|
|
394
|
-
*
|
|
395
|
-
* @defaultValue
|
|
403
|
+
* Break force threshold (Newtons).
|
|
404
|
+
* @defaultValue 10000000000000000
|
|
396
405
|
*/
|
|
397
406
|
breakForce: Float;
|
|
398
407
|
/**
|
|
399
|
-
*
|
|
400
|
-
* @defaultValue
|
|
408
|
+
* Break torque threshold (N·m).
|
|
409
|
+
* @defaultValue 10000000000000000
|
|
401
410
|
*/
|
|
402
411
|
breakTorque: Float;
|
|
403
412
|
/**
|
|
404
|
-
*
|
|
413
|
+
* Enable collision between constrainer and constrainee bodies.
|
|
405
414
|
* @defaultValue false
|
|
406
415
|
*/
|
|
407
416
|
enableCollision: boolean;
|
|
408
417
|
};
|
|
409
418
|
/**
|
|
410
|
-
*
|
|
419
|
+
* Displays an editor-only label in the 3D view.
|
|
411
420
|
*/
|
|
412
421
|
export type Label = {
|
|
413
422
|
/**
|
|
414
|
-
*
|
|
423
|
+
* Label title text.
|
|
415
424
|
*/
|
|
416
425
|
title: string;
|
|
417
426
|
/**
|
|
418
|
-
*
|
|
427
|
+
* Label description text.
|
|
419
428
|
*/
|
|
420
429
|
description: string;
|
|
421
430
|
/**
|
|
422
|
-
* Camera
|
|
431
|
+
* Camera framing parameters for navigating to the label.
|
|
423
432
|
* @defaultValue 0,0,0,0,0,0,1
|
|
424
433
|
*/
|
|
425
434
|
camera: Array<Float>;
|
|
426
435
|
/**
|
|
427
|
-
*
|
|
436
|
+
* Camera travel speed (meters/second).
|
|
428
437
|
* @defaultValue 15
|
|
429
438
|
*/
|
|
430
439
|
speed: Float;
|
|
431
440
|
};
|
|
432
441
|
/**
|
|
433
|
-
*
|
|
442
|
+
* Records the entity's lineage through linkers and parentage.
|
|
434
443
|
*/
|
|
435
444
|
export type Lineage = {
|
|
436
445
|
/**
|
|
437
|
-
*
|
|
446
|
+
* UUID chain of linkers that produced this entity.
|
|
438
447
|
*/
|
|
439
448
|
readonly value: Array<UUID>;
|
|
440
449
|
/**
|
|
441
|
-
* UUID of
|
|
450
|
+
* UUID of this entity's parent (default is root).
|
|
442
451
|
*/
|
|
443
452
|
parentUUID: UUID;
|
|
444
453
|
/**
|
|
445
|
-
* Ordinal
|
|
454
|
+
* Ordinal index among siblings (editor-only).
|
|
446
455
|
* @defaultValue 0
|
|
447
456
|
*/
|
|
448
457
|
ordinal: Int32;
|
|
449
458
|
};
|
|
450
459
|
/**
|
|
451
|
-
* Local
|
|
460
|
+
* Local-space axis-aligned bounding box.
|
|
452
461
|
*/
|
|
453
462
|
export type LocalAabb = {
|
|
454
463
|
/**
|
|
455
|
-
*
|
|
464
|
+
* Local AABB minimum corner (x,y,z).
|
|
456
465
|
*/
|
|
457
466
|
min: Vec3;
|
|
458
467
|
/**
|
|
459
|
-
*
|
|
468
|
+
* Local AABB maximum corner (x,y,z).
|
|
460
469
|
*/
|
|
461
470
|
max: Vec3;
|
|
462
471
|
};
|
|
463
472
|
/**
|
|
464
|
-
* Local transform of the entity.
|
|
473
|
+
* Local transform of the entity (position, orientation, scale).
|
|
465
474
|
*/
|
|
466
475
|
export type LocalTransform = {
|
|
467
476
|
/**
|
|
468
|
-
* x, y, z
|
|
477
|
+
* Local position (x, y, z) in meters.
|
|
469
478
|
* @defaultValue 0,0,0
|
|
470
479
|
*/
|
|
471
480
|
position: Vec3;
|
|
472
481
|
/**
|
|
473
|
-
*
|
|
482
|
+
* Local orientation as a quaternion.
|
|
474
483
|
* @defaultValue 0,0,0,1
|
|
475
484
|
*/
|
|
476
485
|
orientation: Quat;
|
|
477
486
|
/**
|
|
478
|
-
* x, y, z
|
|
487
|
+
* Local non-uniform scale (x, y, z).
|
|
479
488
|
* @defaultValue 1,1,1
|
|
480
489
|
*/
|
|
481
490
|
scale: Vec3;
|
|
482
491
|
/**
|
|
483
|
-
*
|
|
492
|
+
* Local orientation as Euler angles (editor-only).
|
|
484
493
|
* @defaultValue 0,0,0
|
|
485
494
|
*/
|
|
486
495
|
eulerOrientation: Vec3;
|
|
487
496
|
/**
|
|
488
|
-
* Last global orientation
|
|
497
|
+
* Last global orientation entered by a user as Euler angles (may be invalid; editor-only).
|
|
489
498
|
* @defaultValue 0,0,0
|
|
490
499
|
*/
|
|
491
500
|
globalEulerOrientation: Vec3;
|
|
492
501
|
};
|
|
493
502
|
/**
|
|
494
|
-
*
|
|
503
|
+
* Assigns a shader to the entity's mesh and provides its input values and specialization constants.
|
|
495
504
|
*/
|
|
496
505
|
export type Material = {
|
|
497
506
|
/**
|
|
498
|
-
*
|
|
507
|
+
* Referenced shader (UUID).
|
|
499
508
|
*/
|
|
500
509
|
shaderRef: AssetRef<Assets.Shader>;
|
|
501
510
|
/**
|
|
502
|
-
*
|
|
511
|
+
* Render both front and back faces (double-sided).
|
|
503
512
|
* @defaultValue false
|
|
504
513
|
*/
|
|
505
514
|
isDoubleSided: boolean;
|
|
506
515
|
/**
|
|
507
|
-
*
|
|
516
|
+
* Shader input values (JSON); schema defined by shaderRef.
|
|
508
517
|
*/
|
|
509
518
|
dataJSON: ShaderDataObject;
|
|
510
519
|
/**
|
|
511
|
-
* Specialization constants
|
|
520
|
+
* Specialization constants (JSON); schema defined by shaderRef.
|
|
512
521
|
*/
|
|
513
522
|
constantsJSON: ShaderDataObject;
|
|
514
523
|
};
|
|
515
524
|
/**
|
|
516
|
-
* Reference to a material.
|
|
525
|
+
* Reference to a material to use for rendering.
|
|
517
526
|
*/
|
|
518
527
|
export type MaterialRef = {
|
|
519
528
|
/**
|
|
520
|
-
*
|
|
529
|
+
* Referenced material (UUID).
|
|
521
530
|
*/
|
|
522
531
|
value: AssetRef<Assets.Material>;
|
|
523
532
|
/**
|
|
524
|
-
* Face culling
|
|
533
|
+
* Face culling override: 0 = inherit from material, 1 = single-sided, 2 = double-sided.
|
|
525
534
|
* @defaultValue 0
|
|
526
535
|
*/
|
|
527
536
|
faceCulling: Int32;
|
|
528
537
|
};
|
|
529
538
|
/**
|
|
530
|
-
*
|
|
539
|
+
* Displays editor-only measurement annotations in the 3D view.
|
|
531
540
|
*/
|
|
532
541
|
export type Measure = {
|
|
533
542
|
/**
|
|
534
|
-
*
|
|
543
|
+
* Measurement type to display.
|
|
535
544
|
* @defaultValue 0
|
|
536
545
|
*/
|
|
537
546
|
type: UInt32;
|
|
538
547
|
/**
|
|
539
|
-
*
|
|
548
|
+
* Display color for the measurement.
|
|
540
549
|
* @defaultValue 1,1,1
|
|
541
550
|
*/
|
|
542
551
|
color: Vec3;
|
|
543
552
|
};
|
|
544
553
|
/**
|
|
545
|
-
* Reference to a mesh.
|
|
554
|
+
* Reference to a mesh to render (with submesh selection).
|
|
546
555
|
*/
|
|
547
556
|
export type MeshRef = {
|
|
548
557
|
/**
|
|
549
|
-
*
|
|
558
|
+
* Referenced mesh (UUID).
|
|
550
559
|
*/
|
|
551
560
|
value: AssetRef<Assets.Mesh>;
|
|
552
561
|
/**
|
|
553
|
-
* Index of the submesh
|
|
562
|
+
* Index of the submesh within the mesh's submesh array.
|
|
554
563
|
* @defaultValue 0
|
|
555
564
|
*/
|
|
556
565
|
submeshIndex: Int32;
|
|
557
566
|
/**
|
|
558
|
-
*
|
|
567
|
+
* Shadow casting mode for this mesh.
|
|
559
568
|
* @defaultValue 1
|
|
560
569
|
*/
|
|
561
570
|
shadowCastingMode: UInt8;
|
|
@@ -565,119 +574,119 @@ export type MeshRef = {
|
|
|
565
574
|
*/
|
|
566
575
|
export type MorphTargets = {
|
|
567
576
|
/**
|
|
568
|
-
*
|
|
577
|
+
* Map from morph target name to weight (commonly 0..1).
|
|
569
578
|
*/
|
|
570
579
|
weights: Record<string, Float>;
|
|
571
580
|
};
|
|
572
581
|
/**
|
|
573
|
-
*
|
|
582
|
+
* Orthographic projection lens with configurable zoom and depth range.
|
|
574
583
|
*/
|
|
575
584
|
export type OrthographicLens = {
|
|
576
585
|
/**
|
|
577
|
-
* Zoom factor
|
|
586
|
+
* Zoom factor applied to the orthographic extents (X,Y). 1 = no zoom.
|
|
578
587
|
* @defaultValue 1,1
|
|
579
588
|
*/
|
|
580
589
|
zoomFactor: Vec2;
|
|
581
590
|
/**
|
|
582
|
-
* Near plane.
|
|
591
|
+
* Near clipping plane distance (meters).
|
|
583
592
|
* @defaultValue 0
|
|
584
593
|
*/
|
|
585
594
|
zNear: Float;
|
|
586
595
|
/**
|
|
587
|
-
* Far plane.
|
|
596
|
+
* Far clipping plane distance (meters).
|
|
588
597
|
* @defaultValue 100
|
|
589
598
|
*/
|
|
590
599
|
zFar: Float;
|
|
591
600
|
};
|
|
592
601
|
/**
|
|
593
|
-
* Overrides
|
|
602
|
+
* Overrides an entity from a subscene: mark for deletion, replace components, or detach specific components.
|
|
594
603
|
*/
|
|
595
604
|
export type Overrider = {
|
|
596
605
|
/**
|
|
597
|
-
* Mark the overridden entity as deleted.
|
|
606
|
+
* Mark the overridden entity as deleted in the composed scene.
|
|
598
607
|
* @defaultValue false
|
|
599
608
|
*/
|
|
600
609
|
deleter: boolean;
|
|
601
610
|
/**
|
|
602
|
-
*
|
|
611
|
+
* Target entity to override.
|
|
603
612
|
*/
|
|
604
613
|
entityRef: EntityRef;
|
|
605
614
|
/**
|
|
606
|
-
* Hashes of
|
|
615
|
+
* Hashes of components to detach from the overridden entity.
|
|
607
616
|
*/
|
|
608
617
|
componentsToDetach: Array<Int32>;
|
|
609
618
|
};
|
|
610
619
|
/**
|
|
611
|
-
*
|
|
620
|
+
* Perspective projection lens with vertical field of view and near/far clipping planes.
|
|
612
621
|
*/
|
|
613
622
|
export type PerspectiveLens = {
|
|
614
623
|
/**
|
|
615
|
-
*
|
|
624
|
+
* Vertical field of view angle in degrees.
|
|
616
625
|
* @defaultValue 60
|
|
617
626
|
*/
|
|
618
627
|
fovy: Float;
|
|
619
628
|
/**
|
|
620
|
-
*
|
|
629
|
+
* Near clipping plane distance (meters).
|
|
621
630
|
* @defaultValue 0.01
|
|
622
631
|
*/
|
|
623
632
|
nearPlane: Float;
|
|
624
633
|
/**
|
|
625
|
-
*
|
|
634
|
+
* Far clipping plane distance (meters). Set to 0 for an infinite far plane.
|
|
626
635
|
* @defaultValue 0
|
|
627
636
|
*/
|
|
628
637
|
farPlane: Float;
|
|
629
638
|
/**
|
|
630
|
-
*
|
|
639
|
+
* Projection center offset for stereoscopic rendering (meters).
|
|
631
640
|
* @defaultValue 0,0
|
|
632
641
|
*/
|
|
633
642
|
offset: Vec2;
|
|
634
643
|
};
|
|
635
644
|
/**
|
|
636
|
-
*
|
|
645
|
+
* Physical surface properties used for contact: friction, restitution, optional contact modification, and trigger mode.
|
|
637
646
|
*/
|
|
638
647
|
export type PhysicsMaterial = {
|
|
639
648
|
/**
|
|
640
|
-
*
|
|
649
|
+
* Static friction coefficient (typically 0..1). 0 feels like ice; higher resists start of motion. Effective value is averaged with the other surface.
|
|
641
650
|
* @defaultValue 0.5
|
|
642
651
|
*/
|
|
643
652
|
staticFriction: Float;
|
|
644
653
|
/**
|
|
645
|
-
*
|
|
654
|
+
* Dynamic (kinetic) friction coefficient (typically 0..1). If greater than staticFriction, staticFriction is clamped up to match. Effective value is averaged with the other surface.
|
|
646
655
|
* @defaultValue 0.5
|
|
647
656
|
*/
|
|
648
657
|
dynamicFriction: Float;
|
|
649
658
|
/**
|
|
650
|
-
* Restitution
|
|
659
|
+
* Restitution (bounciness) in [0,1]. 0 = no bounce; 1 = perfectly elastic. Effective value is averaged with the other surface.
|
|
651
660
|
* @defaultValue 0
|
|
652
661
|
*/
|
|
653
662
|
restitution: Float;
|
|
654
663
|
/**
|
|
655
|
-
*
|
|
664
|
+
* Applied contact velocity offset when colliding (m/s). Only used if modifyContact is true.
|
|
656
665
|
* @defaultValue 0,0,0
|
|
657
666
|
*/
|
|
658
667
|
contactVelocity: Vec3;
|
|
659
668
|
/**
|
|
660
|
-
*
|
|
669
|
+
* Enable contact modification (applies contactVelocity on collisions).
|
|
661
670
|
* @defaultValue false
|
|
662
671
|
*/
|
|
663
672
|
modifyContact: boolean;
|
|
664
673
|
/**
|
|
665
|
-
*
|
|
674
|
+
* Treat associated geometry as a trigger (generates events but no physical response).
|
|
666
675
|
* @defaultValue false
|
|
667
676
|
*/
|
|
668
677
|
isTrigger: boolean;
|
|
669
678
|
};
|
|
670
679
|
/**
|
|
671
|
-
*
|
|
680
|
+
* Infinite plane geometry.
|
|
672
681
|
*/
|
|
673
682
|
export type PlaneGeometry = {
|
|
674
683
|
/**
|
|
675
|
-
*
|
|
684
|
+
* Signed distance from the origin along the plane normal (meters).
|
|
676
685
|
* @defaultValue 0
|
|
677
686
|
*/
|
|
678
687
|
distance: Float;
|
|
679
688
|
/**
|
|
680
|
-
*
|
|
689
|
+
* Unit normal vector of the plane (in local space).
|
|
681
690
|
* @defaultValue 0,1,0
|
|
682
691
|
*/
|
|
683
692
|
normal: Vec3;
|
|
@@ -687,310 +696,310 @@ export type PlaneGeometry = {
|
|
|
687
696
|
*/
|
|
688
697
|
export type PointCloudRef = {
|
|
689
698
|
/**
|
|
690
|
-
*
|
|
699
|
+
* Referenced point cloud (UUID).
|
|
691
700
|
*/
|
|
692
701
|
value: AssetRef<Assets.PointCloud>;
|
|
693
702
|
};
|
|
694
703
|
/**
|
|
695
|
-
*
|
|
704
|
+
* Omnidirectional light source with physically based intensity and falloff. Acts as a point light by default; enable isDirectional to emit parallel rays. Attach a Spot Light component to add a cone cutoff. Can optionally drive the atmosphere sun direction.
|
|
696
705
|
*/
|
|
697
706
|
export type PointLight = {
|
|
698
707
|
/**
|
|
699
|
-
*
|
|
708
|
+
* RGB light color in linear space [0–1]. Multiplies intensity.
|
|
700
709
|
* @defaultValue 1,1,1
|
|
701
710
|
*/
|
|
702
711
|
color: Vec3;
|
|
703
712
|
/**
|
|
704
|
-
*
|
|
713
|
+
* Radiant intensity (W/sr). Controls brightness for physically based shading (inverse-square falloff).
|
|
705
714
|
* @defaultValue 1
|
|
706
715
|
*/
|
|
707
716
|
intensity: Float;
|
|
708
717
|
/**
|
|
709
|
-
*
|
|
718
|
+
* Hard cutoff distance for light influence and culling (meters). Set to 0 for no hard cutoff and physically correct inverse-square attenuation.
|
|
710
719
|
* @defaultValue 0
|
|
711
720
|
*/
|
|
712
721
|
range: Float;
|
|
713
722
|
/**
|
|
714
|
-
*
|
|
723
|
+
* Treat this as a directional light using the entity's orientation; position is ignored.
|
|
715
724
|
* @defaultValue false
|
|
716
725
|
*/
|
|
717
726
|
isDirectional: boolean;
|
|
718
727
|
/**
|
|
719
|
-
*
|
|
728
|
+
* Use this light's direction to control the atmosphere sun direction. Only one light should be marked as the sun; multiple are undefined.
|
|
720
729
|
* @defaultValue false
|
|
721
730
|
*/
|
|
722
731
|
isSun: boolean;
|
|
723
732
|
};
|
|
724
733
|
/**
|
|
725
|
-
*
|
|
734
|
+
* Omnidirectional reflection probe that captures the local environment into a cubemap for specular reflections (IBL).
|
|
726
735
|
*/
|
|
727
736
|
export type ReflectionProbe = {
|
|
728
737
|
/**
|
|
729
|
-
*
|
|
738
|
+
* Offset of the probe capture origin relative to the entity position (meters).
|
|
730
739
|
* @defaultValue 0,0,0
|
|
731
740
|
*/
|
|
732
741
|
offset: Vec3;
|
|
733
742
|
/**
|
|
734
|
-
*
|
|
743
|
+
* Capture near clip distance (meters).
|
|
735
744
|
* @defaultValue 0.1
|
|
736
745
|
*/
|
|
737
746
|
nearDist: Float;
|
|
738
747
|
/**
|
|
739
|
-
*
|
|
748
|
+
* Capture far clip distance (meters).
|
|
740
749
|
* @defaultValue 100
|
|
741
750
|
*/
|
|
742
751
|
farDist: Float;
|
|
743
752
|
/**
|
|
744
|
-
*
|
|
753
|
+
* Reflection cubemap resolution (pixels per face). Higher values increase detail and cost.
|
|
745
754
|
* @defaultValue 128
|
|
746
755
|
*/
|
|
747
756
|
quality: Int32;
|
|
748
757
|
};
|
|
749
758
|
/**
|
|
750
|
-
* Rigid body parameters.
|
|
759
|
+
* Rigid body parameters for dynamic simulation (mass, damping, limits, CCD, and kinematic/gravity behavior).
|
|
751
760
|
*/
|
|
752
761
|
export type RigidBody = {
|
|
753
762
|
/**
|
|
754
|
-
* Mass
|
|
763
|
+
* Mass (kg). A value of 0 is treated as infinite mass (static).
|
|
755
764
|
* @defaultValue 1
|
|
756
765
|
*/
|
|
757
766
|
mass: Float;
|
|
758
767
|
/**
|
|
759
|
-
* Center of mass
|
|
768
|
+
* Center of mass relative to the entity's local transform (meters).
|
|
760
769
|
* @defaultValue 0,0,0
|
|
761
770
|
*/
|
|
762
771
|
centerOfMass: Vec3;
|
|
763
772
|
/**
|
|
764
|
-
* Linear damping coefficient
|
|
773
|
+
* Linear damping coefficient (s^-1). 0 = no damping; must be non-negative.
|
|
765
774
|
* @defaultValue 0
|
|
766
775
|
*/
|
|
767
776
|
linearDamping: Float;
|
|
768
777
|
/**
|
|
769
|
-
* Angular damping coefficient
|
|
778
|
+
* Angular damping coefficient (s^-1). 0 = no damping; must be non-negative.
|
|
770
779
|
* @defaultValue 0.05
|
|
771
780
|
*/
|
|
772
781
|
angularDamping: Float;
|
|
773
782
|
/**
|
|
774
|
-
*
|
|
783
|
+
* Maximum linear velocity (m/s). Must be non-negative.
|
|
775
784
|
* @defaultValue 10000000000000000
|
|
776
785
|
*/
|
|
777
786
|
maxLinearVelocity: Float;
|
|
778
787
|
/**
|
|
779
|
-
*
|
|
788
|
+
* Maximum angular velocity (rad/s). Must be non-negative.
|
|
780
789
|
* @defaultValue 100
|
|
781
790
|
*/
|
|
782
791
|
maxAngularVelocity: Float;
|
|
783
792
|
/**
|
|
784
|
-
*
|
|
793
|
+
* Collision detection mode (CCD). Kinematic bodies do not support Linear/Continuous CCD.
|
|
785
794
|
* @defaultValue 0
|
|
786
795
|
*/
|
|
787
796
|
collisionDetection: UInt8;
|
|
788
797
|
/**
|
|
789
|
-
* Lock motion along/around the specified
|
|
798
|
+
* Lock motion along/around the specified axes.
|
|
790
799
|
* @defaultValue 0
|
|
791
800
|
*/
|
|
792
801
|
lockedAxis: UInt8;
|
|
793
802
|
/**
|
|
794
|
-
*
|
|
803
|
+
* Whether the rigid body is affected by gravity.
|
|
795
804
|
* @defaultValue true
|
|
796
805
|
*/
|
|
797
806
|
useGravity: boolean;
|
|
798
807
|
/**
|
|
799
|
-
*
|
|
808
|
+
* Treat the rigid body as kinematic (unaffected by forces; driven by animation/app logic).
|
|
800
809
|
* @defaultValue false
|
|
801
810
|
*/
|
|
802
811
|
isKinematic: boolean;
|
|
803
812
|
};
|
|
804
813
|
/**
|
|
805
|
-
*
|
|
814
|
+
* Frame-by-frame actuator for rigid bodies. Sets velocities and applies forces/impulses/torques; values are reset each frame.
|
|
806
815
|
*/
|
|
807
816
|
export type RigidBodyActuator = {
|
|
808
817
|
/**
|
|
809
|
-
*
|
|
818
|
+
* Set the body's linear velocity for this frame.
|
|
810
819
|
* @defaultValue 0,0,0
|
|
811
820
|
*/
|
|
812
821
|
linearVelocity: Vec3;
|
|
813
822
|
/**
|
|
814
|
-
*
|
|
823
|
+
* Set the body's angular velocity for this frame.
|
|
815
824
|
* @defaultValue 0,0,0
|
|
816
825
|
*/
|
|
817
826
|
angularVelocity: Vec3;
|
|
818
827
|
/**
|
|
819
|
-
* Force to apply to the body (
|
|
828
|
+
* Force to apply to the body (Newtons).
|
|
820
829
|
* @defaultValue 0,0,0
|
|
821
830
|
*/
|
|
822
831
|
force: Vec3;
|
|
823
832
|
/**
|
|
824
|
-
*
|
|
833
|
+
* Linear impulse to apply to the body (N·s).
|
|
825
834
|
* @defaultValue 0,0,0
|
|
826
835
|
*/
|
|
827
836
|
impulsiveForce: Vec3;
|
|
828
837
|
/**
|
|
829
|
-
* Torque to apply to the body
|
|
838
|
+
* Torque to apply to the body (N·m).
|
|
830
839
|
* @defaultValue 0,0,0
|
|
831
840
|
*/
|
|
832
841
|
torque: Vec3;
|
|
833
842
|
/**
|
|
834
|
-
*
|
|
843
|
+
* Angular impulse to apply to the body (N·m·s).
|
|
835
844
|
* @defaultValue 0,0,0
|
|
836
845
|
*/
|
|
837
846
|
impulsiveTorque: Vec3;
|
|
838
847
|
/**
|
|
839
|
-
*
|
|
848
|
+
* Bitmask of which actuations to apply this frame: 1=linearVelocity, 2=angularVelocity, 4=force, 8=impulsiveForce, 16=torque, 32=impulsiveTorque.
|
|
840
849
|
* @defaultValue 0
|
|
841
850
|
*/
|
|
842
851
|
flags: UInt8;
|
|
843
852
|
};
|
|
844
853
|
/**
|
|
845
|
-
* Reference to a
|
|
854
|
+
* Reference to a subscene (linker); used to compose scenes.
|
|
846
855
|
*/
|
|
847
856
|
export type SceneRef = {
|
|
848
857
|
/**
|
|
849
|
-
*
|
|
858
|
+
* Referenced scene (UUID).
|
|
850
859
|
*/
|
|
851
860
|
value: AssetRef<Assets.Scene>;
|
|
852
861
|
/**
|
|
853
|
-
* Maximum
|
|
862
|
+
* Maximum recursion depth when a scene references itself.
|
|
854
863
|
* @defaultValue 1
|
|
855
864
|
*/
|
|
856
865
|
maxRecursionCount: UInt32;
|
|
857
866
|
};
|
|
858
867
|
/**
|
|
859
|
-
* References a script and
|
|
868
|
+
* References a script and supplies its input values.
|
|
860
869
|
*/
|
|
861
870
|
export type ScriptElement = {
|
|
862
871
|
/**
|
|
863
|
-
*
|
|
872
|
+
* Referenced script (UUID).
|
|
864
873
|
*/
|
|
865
874
|
scriptRef: AssetRef<Assets.Script>;
|
|
866
875
|
/**
|
|
867
|
-
*
|
|
876
|
+
* Script input values in JSON; schema defined by scriptRef.
|
|
868
877
|
*/
|
|
869
878
|
dataJSON: ScriptDataObject;
|
|
870
879
|
};
|
|
871
880
|
/**
|
|
872
|
-
*
|
|
881
|
+
* Holds a set of script elements keyed by UUID.
|
|
873
882
|
*/
|
|
874
883
|
export type ScriptMap = {
|
|
875
884
|
/**
|
|
876
|
-
*
|
|
885
|
+
* Map of script UUID to script element.
|
|
877
886
|
*/
|
|
878
887
|
elements: Record<UUID, ScriptElement>;
|
|
879
888
|
};
|
|
880
889
|
/**
|
|
881
|
-
* Enables a light to cast shadows.
|
|
890
|
+
* Enables a light to cast real-time shadows with configurable map resolution, depth range, and (for directional lights) cascades.
|
|
882
891
|
*/
|
|
883
892
|
export type ShadowCaster = {
|
|
884
893
|
/**
|
|
885
|
-
*
|
|
894
|
+
* Depth bias applied during shadow tests to reduce self-shadowing (acne). Increase to mitigate artifacts; too high causes peter-panning.
|
|
886
895
|
* @defaultValue 0.004
|
|
887
896
|
*/
|
|
888
897
|
bias: Float;
|
|
889
898
|
/**
|
|
890
|
-
*
|
|
899
|
+
* Shadow camera near clip distance (meters). Tighten to improve depth precision.
|
|
891
900
|
* @defaultValue 0.1
|
|
892
901
|
*/
|
|
893
902
|
nearDist: Float;
|
|
894
903
|
/**
|
|
895
|
-
*
|
|
904
|
+
* Shadow camera far clip distance (meters). Use the smallest range that contains casters/receivers.
|
|
896
905
|
* @defaultValue 100
|
|
897
906
|
*/
|
|
898
907
|
farDist: Float;
|
|
899
908
|
/**
|
|
900
|
-
*
|
|
909
|
+
* Shadow map resolution (pixels per side). Higher values increase detail at the cost of memory and performance.
|
|
901
910
|
* @defaultValue 1024
|
|
902
911
|
*/
|
|
903
912
|
quality: Int32;
|
|
904
913
|
/**
|
|
905
|
-
*
|
|
914
|
+
* Directional lights only: cascade split distribution for CSM. 0 = uniform (linear) splits; 1 = logarithmic (more resolution near the camera). Values in [0,1] blend between the two.
|
|
906
915
|
* @defaultValue 0.94
|
|
907
916
|
*/
|
|
908
917
|
cascadeSplitLambda: Float;
|
|
909
918
|
/**
|
|
910
|
-
*
|
|
919
|
+
* Directional lights only: number of cascades for CSM. 0 = static shadow map, 1–4 = increasing cascade count.
|
|
911
920
|
* @defaultValue 4
|
|
912
921
|
*/
|
|
913
922
|
cascadeCount: Int8;
|
|
914
923
|
/**
|
|
915
|
-
*
|
|
924
|
+
* Directional lights only: blend/accumulate all cascades to reduce visible transitions between splits.
|
|
916
925
|
* @defaultValue true
|
|
917
926
|
*/
|
|
918
927
|
accumulateShadowCascades: boolean;
|
|
919
928
|
};
|
|
920
929
|
/**
|
|
921
|
-
* Reference to a skeleton.
|
|
930
|
+
* Reference to a skeleton asset for skinning and animation.
|
|
922
931
|
*/
|
|
923
932
|
export type SkeletonRef = {
|
|
924
933
|
/**
|
|
925
|
-
*
|
|
934
|
+
* Referenced skeleton (UUID).
|
|
926
935
|
*/
|
|
927
936
|
value: AssetRef<Assets.Skeleton>;
|
|
928
937
|
};
|
|
929
938
|
/**
|
|
930
|
-
* Reference to a sound.
|
|
939
|
+
* Reference to a sound asset with playback and spatialization controls.
|
|
931
940
|
*/
|
|
932
941
|
export type SoundRef = {
|
|
933
942
|
/**
|
|
934
|
-
*
|
|
943
|
+
* Referenced sound (UUID).
|
|
935
944
|
*/
|
|
936
945
|
value: AssetRef<Assets.Sound>;
|
|
937
946
|
/**
|
|
938
|
-
*
|
|
947
|
+
* Playback volume [0..1].
|
|
939
948
|
* @defaultValue 1
|
|
940
949
|
*/
|
|
941
950
|
volume: Float;
|
|
942
951
|
/**
|
|
943
|
-
*
|
|
952
|
+
* Stereo pan. −1 = left, 1 = right.
|
|
944
953
|
* @defaultValue 0
|
|
945
954
|
*/
|
|
946
955
|
pan: Float;
|
|
947
956
|
/**
|
|
948
|
-
*
|
|
957
|
+
* Playback speed multiplier (1.0 = normal).
|
|
949
958
|
* @defaultValue 1
|
|
950
959
|
*/
|
|
951
960
|
playSpeed: Float;
|
|
952
961
|
/**
|
|
953
|
-
*
|
|
962
|
+
* Distance at which the sound stays at max volume (meters).
|
|
954
963
|
* @defaultValue 5
|
|
955
964
|
*/
|
|
956
965
|
minDistance: Float;
|
|
957
966
|
/**
|
|
958
|
-
*
|
|
967
|
+
* Distance beyond which the sound is inaudible (meters).
|
|
959
968
|
* @defaultValue 50
|
|
960
969
|
*/
|
|
961
970
|
maxDistance: Float;
|
|
962
971
|
/**
|
|
963
|
-
*
|
|
972
|
+
* Scale factor for the Doppler effect.
|
|
964
973
|
* @defaultValue 1
|
|
965
974
|
*/
|
|
966
975
|
dopplerFactor: Float;
|
|
967
976
|
/**
|
|
968
|
-
*
|
|
977
|
+
* Rolloff factor for distance attenuation.
|
|
969
978
|
* @defaultValue 1
|
|
970
979
|
*/
|
|
971
980
|
attenuationRolloffFactor: Float;
|
|
972
981
|
/**
|
|
973
|
-
*
|
|
982
|
+
* Distance attenuation model.
|
|
974
983
|
* @defaultValue 0
|
|
975
984
|
*/
|
|
976
985
|
attenuationModel: UInt8;
|
|
977
986
|
/**
|
|
978
|
-
* Behavior
|
|
987
|
+
* Behavior when the sound becomes inaudible.
|
|
979
988
|
* @defaultValue 0
|
|
980
989
|
*/
|
|
981
990
|
inaudibleBehavior: UInt8;
|
|
982
991
|
/**
|
|
983
|
-
*
|
|
992
|
+
* Playback state.
|
|
984
993
|
* @defaultValue 0
|
|
985
994
|
*/
|
|
986
995
|
playState: UInt8;
|
|
987
996
|
/**
|
|
988
|
-
* Whether
|
|
997
|
+
* Whether the sound loops.
|
|
989
998
|
* @defaultValue false
|
|
990
999
|
*/
|
|
991
1000
|
looping: boolean;
|
|
992
1001
|
/**
|
|
993
|
-
*
|
|
1002
|
+
* Autoplay when the simulation starts.
|
|
994
1003
|
* @defaultValue false
|
|
995
1004
|
*/
|
|
996
1005
|
autoPlayOnStart: boolean;
|
|
@@ -1000,65 +1009,56 @@ export type SoundRef = {
|
|
|
1000
1009
|
*/
|
|
1001
1010
|
export type SphereGeometry = {
|
|
1002
1011
|
/**
|
|
1003
|
-
* Radius of the sphere.
|
|
1012
|
+
* Radius of the sphere (meters).
|
|
1004
1013
|
* @defaultValue 0.5
|
|
1005
1014
|
*/
|
|
1006
1015
|
radius: Float;
|
|
1007
1016
|
/**
|
|
1008
|
-
*
|
|
1017
|
+
* Local offset of the geometry origin (meters).
|
|
1009
1018
|
* @defaultValue 0,0,0
|
|
1010
1019
|
*/
|
|
1011
1020
|
offset: Vec3;
|
|
1012
1021
|
};
|
|
1013
1022
|
/**
|
|
1014
|
-
*
|
|
1023
|
+
* Displays an editor-only spline in the 3D view.
|
|
1015
1024
|
*/
|
|
1016
1025
|
export type Spline = {
|
|
1017
1026
|
/**
|
|
1018
|
-
*
|
|
1027
|
+
* Spline interpolation type.
|
|
1019
1028
|
* @defaultValue 0
|
|
1020
1029
|
*/
|
|
1021
1030
|
type: UInt32;
|
|
1022
1031
|
/**
|
|
1023
|
-
*
|
|
1032
|
+
* Display color of the curve.
|
|
1024
1033
|
* @defaultValue 1,1,1
|
|
1025
1034
|
*/
|
|
1026
1035
|
color: Vec3;
|
|
1027
1036
|
/**
|
|
1028
|
-
*
|
|
1037
|
+
* Catmull-Rom tension (only when type is Catmull-Rom).
|
|
1029
1038
|
* @defaultValue 0.5
|
|
1030
1039
|
*/
|
|
1031
1040
|
tension: Float;
|
|
1032
1041
|
};
|
|
1033
1042
|
/**
|
|
1034
|
-
* Adds a cutoff to a
|
|
1043
|
+
* Adds a cone cutoff to a light, producing a spotlight. Requires a Point Light component for color/intensity and falloff.
|
|
1035
1044
|
*/
|
|
1036
1045
|
export type SpotLight = {
|
|
1037
1046
|
/**
|
|
1038
|
-
*
|
|
1047
|
+
* Outer cone half-angle in degrees. Light intensity falls to zero outside this angle.
|
|
1039
1048
|
* @defaultValue 30
|
|
1040
1049
|
*/
|
|
1041
1050
|
cutoff: Float;
|
|
1042
1051
|
/**
|
|
1043
|
-
*
|
|
1052
|
+
* Optional IES photometric profile (2D texture). Modulates emitted intensity by direction; leave empty for uniform distribution.
|
|
1044
1053
|
*/
|
|
1045
1054
|
IESProfile: AssetRef<Assets.Texture>;
|
|
1046
1055
|
};
|
|
1047
1056
|
/**
|
|
1048
|
-
*
|
|
1049
|
-
*/
|
|
1050
|
-
export type StereoscopicLens = {
|
|
1051
|
-
/**
|
|
1052
|
-
* Projection matrix.
|
|
1053
|
-
*/
|
|
1054
|
-
cs_from_vs: Mat4;
|
|
1055
|
-
};
|
|
1056
|
-
/**
|
|
1057
|
-
* Tags used to filter entities.
|
|
1057
|
+
* Free-form tags used to group and filter entities.
|
|
1058
1058
|
*/
|
|
1059
1059
|
export type Tags = {
|
|
1060
1060
|
/**
|
|
1061
|
-
*
|
|
1061
|
+
* List of tags applied to this entity.
|
|
1062
1062
|
*/
|
|
1063
1063
|
value: Array<string>;
|
|
1064
1064
|
};
|
|
@@ -1088,50 +1088,50 @@ export type VehicleController = {
|
|
|
1088
1088
|
rearRightWheel: EntityRef;
|
|
1089
1089
|
};
|
|
1090
1090
|
/**
|
|
1091
|
-
*
|
|
1091
|
+
* View filtering and display controls applied to the referenced volume.
|
|
1092
1092
|
*/
|
|
1093
1093
|
export type VolumeFilter = {
|
|
1094
1094
|
/**
|
|
1095
|
-
*
|
|
1095
|
+
* Displayed voxel intensity range [min, max]. Values outside the material's valid range are clamped/ignored.
|
|
1096
1096
|
* @defaultValue 0,1
|
|
1097
1097
|
*/
|
|
1098
1098
|
range: Vec2;
|
|
1099
1099
|
/**
|
|
1100
|
-
* Apply
|
|
1100
|
+
* Apply Gaussian smoothing when sampling voxels.
|
|
1101
1101
|
* @defaultValue false
|
|
1102
1102
|
*/
|
|
1103
1103
|
applyGaussianFiltering: boolean;
|
|
1104
1104
|
/**
|
|
1105
|
-
*
|
|
1105
|
+
* Sample texels without hardware filtering (nearest).
|
|
1106
1106
|
* @defaultValue false
|
|
1107
1107
|
*/
|
|
1108
1108
|
sampleUnfiltered: boolean;
|
|
1109
1109
|
/**
|
|
1110
|
-
* Whether
|
|
1110
|
+
* Whether this volume is visible in the MPR (multi-planar reconstruction) view.
|
|
1111
1111
|
* @defaultValue true
|
|
1112
1112
|
*/
|
|
1113
1113
|
enableMPR: boolean;
|
|
1114
1114
|
/**
|
|
1115
|
-
* Whether
|
|
1115
|
+
* Whether this volume is visible in the 3D view.
|
|
1116
1116
|
* @defaultValue true
|
|
1117
1117
|
*/
|
|
1118
1118
|
enable3D: boolean;
|
|
1119
1119
|
};
|
|
1120
1120
|
/**
|
|
1121
|
-
* Reference to
|
|
1121
|
+
* Reference to the volume material used for shading and transfer functions.
|
|
1122
1122
|
*/
|
|
1123
1123
|
export type VolumeMaterialRef = {
|
|
1124
1124
|
/**
|
|
1125
|
-
*
|
|
1125
|
+
* Referenced volume material (UUID).
|
|
1126
1126
|
*/
|
|
1127
1127
|
value: AssetRef<Assets.VolumeMaterial>;
|
|
1128
1128
|
};
|
|
1129
1129
|
/**
|
|
1130
|
-
* Reference to a
|
|
1130
|
+
* Reference to a volumetric dataset stored as a 3D texture (voxels).
|
|
1131
1131
|
*/
|
|
1132
1132
|
export type VolumeRef = {
|
|
1133
1133
|
/**
|
|
1134
|
-
* UUID
|
|
1134
|
+
* Referenced 3D texture (UUID) containing the volume voxels.
|
|
1135
1135
|
*/
|
|
1136
1136
|
texture3dRef: AssetRef<Assets.Texture3D>;
|
|
1137
1137
|
};
|