@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.
@@ -18,80 +18,80 @@ export type Euid = {
18
18
  rtid: RTID;
19
19
  };
20
20
  /**
21
- * Animation controller with reference to an animation graph and an animation set. Enables skeletal animation on its skinned mesh descendents whose skeleton is compatible with the animations in the animation set.
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
- * UUID of the referenced animation graph.
25
+ * Referenced Animation Graph (UUID).
26
26
  */
27
27
  animationGraphRef: AssetRef<Assets.AnimationGraph>;
28
28
  /**
29
- * UUID of the referenced animation set.
29
+ * Referenced Animation Set (UUID).
30
30
  */
31
31
  animationSetRef: AssetRef<Assets.AnimationSet>;
32
32
  /**
33
- * Input values as described in the referenced animation graph in their original JSON format.
33
+ * Animation Graph input parameters in JSON format.
34
34
  */
35
35
  dataJSON: AnimationGraphDataObject;
36
36
  /**
37
- * Reference to the entity with the bone component that corresponds the root bone of the skeleton.
37
+ * Entity containing the Bone component for the skeleton's root bone.
38
38
  */
39
39
  rootBoneEntityRef: EntityRef;
40
40
  /**
41
- * Whether or not root motion is enabled.
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
- * Animation sequence controller with reference to an animation sequence and assigned entities.
47
+ * Controls playback of an Animation Sequence; assigns tracks to entities.
48
48
  */
49
49
  export type AnimationSequenceController = {
50
50
  /**
51
- * A reference to an animation sequence.
51
+ * Referenced Animation Sequence (UUID).
52
52
  */
53
53
  animationSequenceRef: AssetRef<Assets.AnimationSequence>;
54
54
  /**
55
- * Track to entity map. Key is track uuid, value is the entity to assign to it.
55
+ * Map from track UUID to assigned entity.
56
56
  */
57
57
  entities: Record<UUID, EntityRef>;
58
58
  /**
59
- * The speed at which to play the animation sequence. The sequence will go in reverse if set to a value lower than 0.
59
+ * Playback speed multiplier. Negative values play in reverse.
60
60
  * @defaultValue 1
61
61
  */
62
62
  playbackSpeed: Float;
63
63
  /**
64
- * The normalized offset at which to start the playback.
64
+ * Normalized start offset [0, 1].
65
65
  * @defaultValue 0
66
66
  */
67
67
  startOffset: Float;
68
68
  /**
69
- * The normalized offset at which to stop the playback (or loop back to start offset).
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
- * Whether or not the animation loops when it reaches the end of the sequence.
74
+ * Loop playback when reaching the stop offset.
75
75
  * @defaultValue false
76
76
  */
77
77
  loop: boolean;
78
78
  /**
79
- * The play state of the animation.
79
+ * Current playback state.
80
80
  * @defaultValue 0
81
81
  */
82
82
  playState: UInt8;
83
83
  /**
84
- * The offset to seek at next frame. Must be in the [0, 1] range.
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
- * Links entity to bone in skeleton.
90
+ * Associates this entity with a bone in a skeleton (for attachments and transforms).
91
91
  */
92
92
  export type Bone = {
93
93
  /**
94
- * Index of bone in skeleton.
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
- * Width, height and depth of the box.
103
+ * Box dimensions (width, height, depth) in meters.
104
104
  * @defaultValue 1,1,1
105
105
  */
106
106
  dimension: Vec3;
107
107
  /**
108
- * Geometry offset.
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
- * UUID of the referenced render graph this camera should use.
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
- * Input values as described in the referenced render graph in their original JSON format.
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 spheres at each end of the capsule.
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 part of the capsule.
141
+ * Height of the cylindrical mid-section (meters).
142
142
  * @defaultValue 1
143
143
  */
144
144
  height: Float;
145
145
  /**
146
- * Alignment axis. 0 for X, 1 for Y, 2 for Z.
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
- * Geometry offset.
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
- * Character controller used for movement constrained by collisions without having to deal with a rigid body. A character controller is kinematic, and so is not affected by forces. It uses its own tweaked collision algorithm to give a good feeling while controlling the character.
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
- * Step offset. If the height of a step is greater than stepOffset, the controller cannot climb automatically and gets stuck.
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
- * Slope limit in degrees. A slope steeper than the slopeLimit will not be walkable by the controller.
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
- * The character's collision skin width.
171
+ * Collision skin width (meters).
172
172
  * @defaultValue 0
173
173
  */
174
174
  skinWidth: Float;
175
175
  /**
176
- * Displacement vector for current frame.
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
- * UUID of the referenced collision geometry.
186
+ * Referenced collision geometry (UUID).
187
187
  */
188
188
  collisionGeometryRef: AssetRef<Assets.CollisionGeometry>;
189
189
  };
190
190
  /**
191
- * A physics constraint that can be configured along 6 degrees of freedom. In its default state it behaves as a fixed constraint - that is, it rigidly fixes the constraint frames of its two entities. However, individual degrees of freedom may be unlocked to permit any combination of rotation around the x-, y- and z- axes, and translation along these axes.
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 axis.
195
+ * Unlock motion along/around the specified axes.
196
196
  * @defaultValue 0
197
197
  */
198
198
  unlockedMotion: UInt32;
199
199
  /**
200
- * The lower distance of the limit.
200
+ * Lower linear limit per axis (meters).
201
201
  * @defaultValue 0,0,0
202
202
  */
203
203
  motionLowerLimit: Vec3;
204
204
  /**
205
- * The upper distance of the limit.
205
+ * Upper linear limit per axis (meters).
206
206
  * @defaultValue 0,0,0
207
207
  */
208
208
  motionUpperLimit: Vec3;
209
209
  /**
210
- * If greater than zero, the limit is soft, i.e. a spring pulls the joint back to the limit.
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
- * If greater than zero, this is the damping of the limit spring.
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
- * The limit angle from the Y-axis and the Z-axis of the constraint frame. The cone limit is used if either or both swing axes are limited. The extents are symmetrical and measured in the frame of the parent. If only one swing degree of freedom is limited, the corresponding value from the cone limit defines the limit range. An angle of 0° will not restrict the rotation around the axis. The maximum value for each angle is 180°.
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
- * If greater than zero, the limit is soft, i.e. a spring pulls the joint back to the limit.
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
- * If greater than zero, this is the damping of the limit spring.
230
+ * Swing limit spring damping (N·m·s/rad).
231
231
  * @defaultValue 0
232
232
  */
233
233
  swingSpringDamping: Float;
234
234
  /**
235
- * The twist limit controls the range of motion around the twist axis. The limit angle range is (-360, 360).
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
- * If greater than zero, the limit is soft, i.e. a spring pulls the joint back to the limit.
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
- * If greater than zero, this is the damping of the limit spring.
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
- * If greater than zero, the limit is soft, i.e. a spring pulls the joint back to the limit.
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
- * If greater than zero, this is the damping of the limit spring.
260
+ * Linear drive damping per axis (N·s/m).
261
261
  * @defaultValue 0,0,0
262
262
  */
263
263
  linearDamping: Vec3;
264
264
  /**
265
- * The maximum impulse or force that can be exerted by the drive. -1 for no limit.
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
- * If greater than zero, the limit is soft, i.e. a spring pulls the joint back to the limit.
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
- * If greater than zero, this is the damping of the limit spring.
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
- * The maximum impulse or force that can be exerted by the drive. -1 for no limit.
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
- * The drive type
285
+ * Drive type: apply as force or as acceleration.
286
286
  * @defaultValue 1
287
287
  */
288
288
  type: Int32;
289
289
  /**
290
- * The goal position for linear drive.
290
+ * Target linear position offset (meters).
291
291
  * @defaultValue 0,0,0
292
292
  */
293
293
  goalPosition: Vec3;
294
294
  /**
295
- * The goal orientation for angular drive.
295
+ * Target angular orientation.
296
296
  * @defaultValue 0,0,0,1
297
297
  */
298
298
  goalOrientation: Quat;
299
299
  /**
300
- * The goal velocity for linear drive.
300
+ * Target linear velocity (m/s).
301
301
  * @defaultValue 0,0,0
302
302
  */
303
303
  linearVelocity: Vec3;
304
304
  /**
305
- * The goal velocity for angular drive.
305
+ * Target angular velocity (rad/s).
306
306
  * @defaultValue 0,0,0
307
307
  */
308
308
  angularVelocity: Vec3;
309
309
  };
310
310
  /**
311
- * Culling geometry. Add this component in addition to another geometry component (e.g. box geometry, sphere geometry, etc.) to enable culling geometry.
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 geometry will only display elements (vertices or voxels) inside the geometry. Subtractive will only display elements outside the geometry.
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. 0 for X, 1 for Y, 2 for Z.
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
- * Geometry offset.
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
- * Name of the entity.
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
- * Decal Projector.
364
+ * Projects a material onto scene surfaces within the projector's box volume.
356
365
  */
357
366
  export type DecalProjector = {
358
367
  /**
359
- * Z-Index order of the decal projection. The higher index will render on top of the lower ones.
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
- * The environment of a scene. Used to give a scene a skybox.
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
- * UUID of the skybox cubemap.
378
+ * Skybox cubemap used as the scene background (no lighting effect).
370
379
  */
371
380
  skyboxUUID: AssetRef<Assets.Cubemap>;
372
381
  /**
373
- * Reference to the radiance cubemap.
382
+ * Specular radiance cubemap (prefiltered) used for PBR reflections.
374
383
  */
375
384
  radianceUUID: AssetRef<Assets.Cubemap>;
376
385
  /**
377
- * Reference to the irradiance cubemap.
386
+ * Diffuse irradiance cubemap used for ambient PBR lighting.
378
387
  */
379
388
  irradianceUUID: AssetRef<Assets.Cubemap>;
380
389
  };
381
390
  /**
382
- * Base component of all the other joint components (revolute_joint, etc.). By itself it will lock the orientations and distances of the constrainer and constrainee.
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
- * An entity that is a rigid body.
395
+ * Entity with a Rigid Body to be constrained.
387
396
  */
388
397
  constrainee: EntityRef;
389
398
  /**
390
- * An entity that is a rigid or static body, or simply null.
399
+ * Entity acting as constrainer (rigid/static) or null to constrain to world origin.
391
400
  */
392
401
  constrainer: EntityRef;
393
402
  /**
394
- * The force that needs to be applied for this joint to break.
395
- * @defaultValue 10
403
+ * Break force threshold (Newtons).
404
+ * @defaultValue 10000000000000000
396
405
  */
397
406
  breakForce: Float;
398
407
  /**
399
- * The torque that needs to be applied for this joint to break.
400
- * @defaultValue 10
408
+ * Break torque threshold (N·m).
409
+ * @defaultValue 10000000000000000
401
410
  */
402
411
  breakTorque: Float;
403
412
  /**
404
- * Whether to enable collision between constrainer and constrainee.
413
+ * Enable collision between constrainer and constrainee bodies.
405
414
  * @defaultValue false
406
415
  */
407
416
  enableCollision: boolean;
408
417
  };
409
418
  /**
410
- * Display a label in the 3d view.
419
+ * Displays an editor-only label in the 3D view.
411
420
  */
412
421
  export type Label = {
413
422
  /**
414
- * Title of the label.
423
+ * Label title text.
415
424
  */
416
425
  title: string;
417
426
  /**
418
- * Description of the label.
427
+ * Label description text.
419
428
  */
420
429
  description: string;
421
430
  /**
422
- * Camera distance from the label.
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
- * Travel speed in units per second.
436
+ * Camera travel speed (meters/second).
428
437
  * @defaultValue 15
429
438
  */
430
439
  speed: Float;
431
440
  };
432
441
  /**
433
- * Lineage of the entity through linkers.
442
+ * Records the entity's lineage through linkers and parentage.
434
443
  */
435
444
  export type Lineage = {
436
445
  /**
437
- * UUIDs of the hierarchy of linkers that brought this entity.
446
+ * UUID chain of linkers that produced this entity.
438
447
  */
439
448
  readonly value: Array<UUID>;
440
449
  /**
441
- * UUID of the parent of this entity (default is root).
450
+ * UUID of this entity's parent (default is root).
442
451
  */
443
452
  parentUUID: UUID;
444
453
  /**
445
- * Ordinal number of this entity in respect of its siblings.
454
+ * Ordinal index among siblings (editor-only).
446
455
  * @defaultValue 0
447
456
  */
448
457
  ordinal: Int32;
449
458
  };
450
459
  /**
451
- * Local Axis Aligned Bounding Box of the entity.
460
+ * Local-space axis-aligned bounding box.
452
461
  */
453
462
  export type LocalAabb = {
454
463
  /**
455
- * Minimum point of the box.
464
+ * Local AABB minimum corner (x,y,z).
456
465
  */
457
466
  min: Vec3;
458
467
  /**
459
- * Maximum point of the box.
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 position of the entity.
477
+ * Local position (x, y, z) in meters.
469
478
  * @defaultValue 0,0,0
470
479
  */
471
480
  position: Vec3;
472
481
  /**
473
- * Orientation of the entity expressed as a quaternion.
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 scale of the entity.
487
+ * Local non-uniform scale (x, y, z).
479
488
  * @defaultValue 1,1,1
480
489
  */
481
490
  scale: Vec3;
482
491
  /**
483
- * Orientation of the entity expressed as euler angles.
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 of the entity expressed as euler angles submitted by a user. This value may not be valid, and should be checked.
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
- * References a shader and specifies input values if needed.
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
- * UUID of the referenced shader.
507
+ * Referenced shader (UUID).
499
508
  */
500
509
  shaderRef: AssetRef<Assets.Shader>;
501
510
  /**
502
- * Whether the material is double sided or not.
511
+ * Render both front and back faces (double-sided).
503
512
  * @defaultValue false
504
513
  */
505
514
  isDoubleSided: boolean;
506
515
  /**
507
- * Input values as described in the referenced shader in their original JSON format.
516
+ * Shader input values (JSON); schema defined by shaderRef.
508
517
  */
509
518
  dataJSON: ShaderDataObject;
510
519
  /**
511
- * Specialization constants values as described in the referenced shader in their original JSON format.
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
- * UUID of the referenced material.
529
+ * Referenced material (UUID).
521
530
  */
522
531
  value: AssetRef<Assets.Material>;
523
532
  /**
524
- * Face culling mode. 0 to inherit from material, 1 for single sided, 2 for double sided.
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
- * Display a measure in the 3d view.
539
+ * Displays editor-only measurement annotations in the 3D view.
531
540
  */
532
541
  export type Measure = {
533
542
  /**
534
- * Define the type of the measure.
543
+ * Measurement type to display.
535
544
  * @defaultValue 0
536
545
  */
537
546
  type: UInt32;
538
547
  /**
539
- * Color of the measure
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
- * UUID of the referenced mesh.
558
+ * Referenced mesh (UUID).
550
559
  */
551
560
  value: AssetRef<Assets.Mesh>;
552
561
  /**
553
- * Index of the submesh inside the mesh's submesh array.
562
+ * Index of the submesh within the mesh's submesh array.
554
563
  * @defaultValue 0
555
564
  */
556
565
  submeshIndex: Int32;
557
566
  /**
558
- * Whether or not this mesh casts shadows.
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
- * Weights assigned to morph targets of the submesh.
577
+ * Map from morph target name to weight (commonly 0..1).
569
578
  */
570
579
  weights: Record<string, Float>;
571
580
  };
572
581
  /**
573
- * A lens that applies an orthographic projection.
582
+ * Orthographic projection lens with configurable zoom and depth range.
574
583
  */
575
584
  export type OrthographicLens = {
576
585
  /**
577
- * Zoom factor to apply to the projection.
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 a given entity in a sub scene.
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
- * Entity to override.
611
+ * Target entity to override.
603
612
  */
604
613
  entityRef: EntityRef;
605
614
  /**
606
- * Hashes of the components to detach from the overridden entity.
615
+ * Hashes of components to detach from the overridden entity.
607
616
  */
608
617
  componentsToDetach: Array<Int32>;
609
618
  };
610
619
  /**
611
- * A lens that applies a perspective projection.
620
+ * Perspective projection lens with vertical field of view and near/far clipping planes.
612
621
  */
613
622
  export type PerspectiveLens = {
614
623
  /**
615
- * Field of view angle in the y direction.
624
+ * Vertical field of view angle in degrees.
616
625
  * @defaultValue 60
617
626
  */
618
627
  fovy: Float;
619
628
  /**
620
- * Distance from the viewer to the near clipping plane.
629
+ * Near clipping plane distance (meters).
621
630
  * @defaultValue 0.01
622
631
  */
623
632
  nearPlane: Float;
624
633
  /**
625
- * Distance from the viewer to the far clipping plane.
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
- * Offset of the projection for stereoscopic rendering.
639
+ * Projection center offset for stereoscopic rendering (meters).
631
640
  * @defaultValue 0,0
632
641
  */
633
642
  offset: Vec2;
634
643
  };
635
644
  /**
636
- * Physics material which represents a set of physical surface properties.
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
- * The friction coefficient applied between this surface and another surface if they are not moving lateral to each other. Usually a value from 0 to 1. A value of zero feels like ice, a value of 1 will make it very hard to get the object moving. Resulting static friction of a physics body colliding with another is determined by the average of both bodies' static friction coefficient.
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
- * The friction coefficient applied between this surface and another surface if they are moving relative to each other. Usually a value from 0 to 1. A value of zero feels like ice, a value of 1 will make it very hard to get the object moving. If set to greater than staticFriction, the effective value of staticFriction will be increased to match. Resulting dynamic friction of a physics body colliding with another is determined by the average of both bodies' dynamic friction coefficient.
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 coefficient, or bounciness of surface. A coefficient of 0 indicates as little bounce as possible, higher values up to 1.0 result in more bounce. Should be in the range [0,1]. Resulting bounciness of a physics body colliding with another is determined by the average of both bodies' 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
- * The velocity applied to the contact between this physics body and another body. Only applies if modifyContact is true.
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
- * Whether to modify the contact when this physics body collides with another body.
669
+ * Enable contact modification (applies contactVelocity on collisions).
661
670
  * @defaultValue false
662
671
  */
663
672
  modifyContact: boolean;
664
673
  /**
665
- * Whether to consider the geometry associated to this physics material as a trigger or not.
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
- * Plane geometry.
680
+ * Infinite plane geometry.
672
681
  */
673
682
  export type PlaneGeometry = {
674
683
  /**
675
- * Distance from the origin in the plane's normal direction.
684
+ * Signed distance from the origin along the plane normal (meters).
676
685
  * @defaultValue 0
677
686
  */
678
687
  distance: Float;
679
688
  /**
680
- * Normal of the plane.
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
- * UUID of the referenced point cloud.
699
+ * Referenced point cloud (UUID).
691
700
  */
692
701
  value: AssetRef<Assets.PointCloud>;
693
702
  };
694
703
  /**
695
- * A light with color and intensity. A point light by default, add a spot light component to add a cutoff. Can be parameterized to simulate the atmosphere sun.
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
- * Light color.
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
- * Light intensity.
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
- * The range for the point light. If the range is 0, then physically correct point light attenuation function is used.
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
- * Make this light directional, position is ignored in this case.
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
- * Make this light direction control the atmosphere sun direction. If more than one light is marked to be a sun results are undefined.
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
- * Omni directional reflection probe parameters, used for local cubemap reflection generation.
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
- * x, y, z offset of the probe reflection origin.
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
- * Distance to the near plane.
743
+ * Capture near clip distance (meters).
735
744
  * @defaultValue 0.1
736
745
  */
737
746
  nearDist: Float;
738
747
  /**
739
- * Distance to the far plane.
748
+ * Capture far clip distance (meters).
740
749
  * @defaultValue 100
741
750
  */
742
751
  farDist: Float;
743
752
  /**
744
- * Resolution of the reflection map.
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 of the rigid body. A value of 0 is interpreted as infinite 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. Relative to the entity's transform.
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. Used to slow down the rigid body's linear velocity. Zero represents no damping. Must be non-negative.
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. Used to slow down the rigid body's angular velocity, i.e. how much it rotates. Zero represents no damping. Must be non-negative.
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
- * The maximum linear velocity permitted for this body in m/s. Must be non-negative.
783
+ * Maximum linear velocity (m/s). Must be non-negative.
775
784
  * @defaultValue 10000000000000000
776
785
  */
777
786
  maxLinearVelocity: Float;
778
787
  /**
779
- * The maximum angular velocity permitted for this body in rad/s. Must be non-negative.
788
+ * Maximum angular velocity (rad/s). Must be non-negative.
780
789
  * @defaultValue 100
781
790
  */
782
791
  maxAngularVelocity: Float;
783
792
  /**
784
- * The type of collision detection to use for this rigid body.
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 axis.
798
+ * Lock motion along/around the specified axes.
790
799
  * @defaultValue 0
791
800
  */
792
801
  lockedAxis: UInt8;
793
802
  /**
794
- * Controls whether rigid body is affected by gravity.
803
+ * Whether the rigid body is affected by gravity.
795
804
  * @defaultValue true
796
805
  */
797
806
  useGravity: boolean;
798
807
  /**
799
- * Specifies if rigid body is kinematic. Kinematic rigid bodies are not affected by forces such as gravity.
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
- * Rigid body actuator. Represent forces and torques that are applied during a simulation step. All values are reset each frame.
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
- * Sets the body's linear velocity
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
- * Sets the body's angular velocity
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 (mass * length / time^2, a force)
828
+ * Force to apply to the body (Newtons).
820
829
  * @defaultValue 0,0,0
821
830
  */
822
831
  force: Vec3;
823
832
  /**
824
- * Impulse to apply to the body (mass * length / time, i.e., force * time)
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
- * Impulsive torque to apply to the body
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
- * Which attributes are set for the next frame. 1 = linearVelocity, 2 = angularVelocity, 4 = force, 8 = impulsiveForce, 16 = torque, 32 = impulsiveTorque
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 scene.
854
+ * Reference to a subscene (linker); used to compose scenes.
846
855
  */
847
856
  export type SceneRef = {
848
857
  /**
849
- * UUID of the referenced scene.
858
+ * Referenced scene (UUID).
850
859
  */
851
860
  value: AssetRef<Assets.Scene>;
852
861
  /**
853
- * Maximum number of times a scene appears when it references itself.
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 specifies input values if needed.
868
+ * References a script and supplies its input values.
860
869
  */
861
870
  export type ScriptElement = {
862
871
  /**
863
- * UUID of the referenced script.
872
+ * Referenced script (UUID).
864
873
  */
865
874
  scriptRef: AssetRef<Assets.Script>;
866
875
  /**
867
- * Input values as described in the referenced script in their original JSON format.
876
+ * Script input values in JSON; schema defined by scriptRef.
868
877
  */
869
878
  dataJSON: ScriptDataObject;
870
879
  };
871
880
  /**
872
- * References multiple scripts.
881
+ * Holds a set of script elements keyed by UUID.
873
882
  */
874
883
  export type ScriptMap = {
875
884
  /**
876
- * List of scripts.
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
- * Bias to apply to avoid self shadowing artifacts.
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
- * Distance to the near plane.
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
- * Distance to the far plane.
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
- * Resolution of the shadow map.
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
- * For directional lights, adjusts the distribution of cascade splits in Cascaded Shadow Mapping for directional lights. A value of 0 results in uniform (linear) splits across the view frustum, while a value of 1 skews the splits toward the camera, providing higher shadow resolution near the viewer and lower resolution in the distance. Intermediate values blend linear and logarithmic distributions for a balanced result. The value ranges from 0 to 1.
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
- * For directional lights, number of cascades.
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
- * For directional lights, accumulate all shadow cascades.
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
- * UUID of the referenced skeleton.
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
- * UUID of the referenced sound.
943
+ * Referenced sound (UUID).
935
944
  */
936
945
  value: AssetRef<Assets.Sound>;
937
946
  /**
938
- * Volume from 0.0f to 1.0.
947
+ * Playback volume [0..1].
939
948
  * @defaultValue 1
940
949
  */
941
950
  volume: Float;
942
951
  /**
943
- * Pan. -1.0 is left, 1.0 is right.
952
+ * Stereo pan. −1 = left, 1 = right.
944
953
  * @defaultValue 0
945
954
  */
946
955
  pan: Float;
947
956
  /**
948
- * The speed at which the sound will play. 1.0 is normal.
957
+ * Playback speed multiplier (1.0 = normal).
949
958
  * @defaultValue 1
950
959
  */
951
960
  playSpeed: Float;
952
961
  /**
953
- * If distance from audio souce is < minDistance, audio is at max volume.
962
+ * Distance at which the sound stays at max volume (meters).
954
963
  * @defaultValue 5
955
964
  */
956
965
  minDistance: Float;
957
966
  /**
958
- * If distance from audio souce is >= maxDistance, audio is inaudible.
967
+ * Distance beyond which the sound is inaudible (meters).
959
968
  * @defaultValue 50
960
969
  */
961
970
  maxDistance: Float;
962
971
  /**
963
- * Reduce or enhance the doppler effect.
972
+ * Scale factor for the Doppler effect.
964
973
  * @defaultValue 1
965
974
  */
966
975
  dopplerFactor: Float;
967
976
  /**
968
- * Attenuation rolloff factor.
977
+ * Rolloff factor for distance attenuation.
969
978
  * @defaultValue 1
970
979
  */
971
980
  attenuationRolloffFactor: Float;
972
981
  /**
973
- * Attenuation Model.
982
+ * Distance attenuation model.
974
983
  * @defaultValue 0
975
984
  */
976
985
  attenuationModel: UInt8;
977
986
  /**
978
- * Behavior of a sound when it becomes inaudible.
987
+ * Behavior when the sound becomes inaudible.
979
988
  * @defaultValue 0
980
989
  */
981
990
  inaudibleBehavior: UInt8;
982
991
  /**
983
- * The play state of the sound.
992
+ * Playback state.
984
993
  * @defaultValue 0
985
994
  */
986
995
  playState: UInt8;
987
996
  /**
988
- * Whether or not the sound loops.
997
+ * Whether the sound loops.
989
998
  * @defaultValue false
990
999
  */
991
1000
  looping: boolean;
992
1001
  /**
993
- * Whether or not the sound plays automatically when the simulation starts.
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
- * Geometry offset.
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
- * Display a spline in the 3d view.
1023
+ * Displays an editor-only spline in the 3D view.
1015
1024
  */
1016
1025
  export type Spline = {
1017
1026
  /**
1018
- * Define the type of the curve.
1027
+ * Spline interpolation type.
1019
1028
  * @defaultValue 0
1020
1029
  */
1021
1030
  type: UInt32;
1022
1031
  /**
1023
- * Color of the curve.
1032
+ * Display color of the curve.
1024
1033
  * @defaultValue 1,1,1
1025
1034
  */
1026
1035
  color: Vec3;
1027
1036
  /**
1028
- * When type is catmullrom, defines catmullrom's tension.
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 point light to simulate a spot light.
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
- * Cutoff angle.
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
- * Reference to a IES 2d texture.
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
- * A lens that applies a custom projection.
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
- * Tag list.
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
- * Filtering properties applied to the volume.
1091
+ * View filtering and display controls applied to the referenced volume.
1092
1092
  */
1093
1093
  export type VolumeFilter = {
1094
1094
  /**
1095
- * Voxel intensity range displayed, not applicable if outside volume material range.
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 gaussian filtering on voxels.
1100
+ * Apply Gaussian smoothing when sampling voxels.
1101
1101
  * @defaultValue false
1102
1102
  */
1103
1103
  applyGaussianFiltering: boolean;
1104
1104
  /**
1105
- * Are texel values from the voxel texture sampled unfiltered.
1105
+ * Sample texels without hardware filtering (nearest).
1106
1106
  * @defaultValue false
1107
1107
  */
1108
1108
  sampleUnfiltered: boolean;
1109
1109
  /**
1110
- * Whether or not this volume is visible in the MPR view.
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 or not this volume is visible in the 3D view.
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 a material to use with a volume.
1121
+ * Reference to the volume material used for shading and transfer functions.
1122
1122
  */
1123
1123
  export type VolumeMaterialRef = {
1124
1124
  /**
1125
- * UUID of the referenced volume material.
1125
+ * Referenced volume material (UUID).
1126
1126
  */
1127
1127
  value: AssetRef<Assets.VolumeMaterial>;
1128
1128
  };
1129
1129
  /**
1130
- * Reference to a volume made of voxels.
1130
+ * Reference to a volumetric dataset stored as a 3D texture (voxels).
1131
1131
  */
1132
1132
  export type VolumeRef = {
1133
1133
  /**
1134
- * UUID of the referenced 3D texture.
1134
+ * Referenced 3D texture (UUID) containing the volume voxels.
1135
1135
  */
1136
1136
  texture3dRef: AssetRef<Assets.Texture3D>;
1137
1137
  };