@babylonjs/lite-compat 1.26.0-preview → 1.28.0-preview

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/README.md CHANGED
@@ -115,37 +115,38 @@ overloads within a supported area may still be absent.
115
115
 
116
116
  ### `@babylonjs/core`
117
117
 
118
- | Feature area | Status | Notes |
119
- | --------------------------------------------------------------------------------------------------------- | :----: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
120
- | Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`) | ✅ | `Angle` / `Curve3` / `Path3D` partial |
121
- | Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; `beginFrame`/`endFrame`, MSAA/alpha-to-coverage (`currentSampleCount`/`get`/`setAlphaToCoverage`), and manual `scene.render()` unsupported |
122
- | Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` unsupported (use async `GPUPicker`); `scene.meshes` + `getMeshBy*`/`getNodeBy*` now enumerate every mesh via a canonical wrapper registry |
123
- | Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | XR / device-orientation / stereoscopic rigs unsupported |
124
- | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters point lights (⚡ partial); `RectAreaLight` unsupported |
125
- | Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` falls back to single cascade |
118
+ | Feature area | Status | Notes |
119
+ | -------------------------------------------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
120
+ | Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`) | ✅ | `Angle` / `Curve3` / `Path3D` partial |
121
+ | Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; `currentSampleCount` reports the active surface's MSAA count; `beginFrame`/`endFrame`, engine-wide alpha-to-coverage, and manual `scene.render()` unsupported |
122
+ | Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` unsupported (use async `GPUPicker`); `scene.meshes` + `getMeshBy*`/`getNodeBy*` now enumerate every mesh via a canonical wrapper registry |
123
+ | Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | XR / device-orientation / stereoscopic rigs unsupported |
124
+ | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters point lights (⚡ partial); `RectAreaLight` unsupported |
125
+ | Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM |
126
126
  | Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | `CreateLines`/`CreateLineSystem` support fixed-topology line lists and RGBA point colors; `CreateDashedLines` supports uniform-color dashed line lists; `MergeMeshes` bakes positions/normals/UVs and rejects unsupported attributes/animation; `CreateDecal`/`CreateText`/`CreateTiledBox`/`CreateTiledPlane`, `GreasedLine*` (thick lines), `InstancedMesh`, LOD/edges/outline, hardware instances unsupported |
127
- | CSG / CSG2 | ✅ | over Lite boolean ops |
128
- | Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled) |
129
- | Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; `ShaderMaterial` (GLSL), `MultiMaterial`, `BackgroundMaterial` unsupported |
130
- | Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `CubeTexture`, `HDRCubeTexture`) | ⚡ | `HDRCubeTexture` routes to native `loadHdrEnvironment`; `RawTexture2DArray` supports the raw-bytes, image-source/URL, and single-file KTX2 array paths; `RenderTargetTexture` / `MirrorTexture` / `HtmlTexture` unsupported |
131
- | Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | CPU evaluation; loaded glTF skeletal blending supported |
132
- | Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets |
133
- | Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
134
- | Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag / six-DoF / XR-oriented mesh behaviors throw |
135
- | Misc (`Observable`, `Tools`, `SmartArray`, `Tags`, gradients, `PerformanceMonitor`) | ✅ | |
136
- | Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer) | ⚡ | over Lite's AudioV2 port; `MainAudioBus` spatial/analyzer and a second main bus unsupported |
137
- | Physics (`HavokPlugin`, `scene.enablePhysics`/`getPhysicsEngine`, `PhysicsAggregate`/`PhysicsBody`/`PhysicsShape`) | ⚡ | Native Havok V2 forwarding for common body/shape operations; unrecognized shape/motion/prestep enum values throw at the compat boundary |
138
- | Particles (`NodeParticleSystemSet` / `ParticleSystemSet` — Node Particle Editor) | ⚡ | NPE snippet/JSON graphs: `Parse`/`ParseFromSnippetAsync` → `buildAsync` → `start`, incl. per-system `set.systems[i]` runtime (`start`/`animate`/`updateSpeed`/`particleTexture`). Imperative classic/GPU/solid `ParticleSystem` construction + programmatic block authoring unsupported |
139
- | Post-processes, layers (glow/highlight), probes, WebXR | ❌ | not in Babylon Lite — use native Lite `create*Task` functions |
127
+ | CSG / CSG2 | ✅ | over Lite boolean ops |
128
+ | Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled) |
129
+ | Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; `ShaderMaterial` (GLSL), `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` unsupported |
130
+ | Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `CubeTexture`, `HDRCubeTexture`) | ⚡ | `HDRCubeTexture` routes to native `loadHdrEnvironment`; `RawTexture2DArray` supports the raw-bytes, image-source/URL, and single-file KTX2 array paths; `RenderTargetTexture` / `MirrorTexture` / `HtmlTexture` unsupported |
131
+ | Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | CPU evaluation; loaded glTF skeletal blending supported |
132
+ | Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets |
133
+ | Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
134
+ | Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag / six-DoF / XR-oriented mesh behaviors throw |
135
+ | Misc (`Observable`, `Tools`, `SmartArray`, `Tags`, gradients, `PerformanceMonitor`) | ✅ | |
136
+ | Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer) | ⚡ | over Lite's AudioV2 port; `MainAudioBus` spatial/analyzer and a second main bus unsupported |
137
+ | Physics (`HavokPlugin`, `scene.enablePhysics`/`getPhysicsEngine`, `PhysicsAggregate`/`PhysicsBody`/`PhysicsShape`) | ⚡ | Native Havok V2 forwarding for common body/shape operations; unrecognized shape/motion/prestep enum values throw at the compat boundary |
138
+ | Particles (`NodeParticleSystemSet` / `ParticleSystemSet` — Node Particle Editor) | ⚡ | NPE snippet/JSON graphs: `Parse`/`ParseFromSnippetAsync` → `buildAsync` → `start`, incl. per-system `set.systems[i]` runtime (`start`/`animate`/`updateSpeed`/`particleTexture`). Imperative classic/GPU/solid `ParticleSystem` construction + programmatic block authoring unsupported |
139
+ | Post-processes, layers (glow/highlight), probes, WebXR | ❌ | not in Babylon Lite — use native Lite `create*Task` functions |
140
140
 
141
141
  ### `@babylonjs/loaders`
142
142
 
143
- | Feature area | Status | Notes |
144
- | ---------------------------------------------------------------------------------------------- | :----: | --------------------------------------------------------------- |
145
- | glTF 2.0 (+ extensions), `.babylon` | ✅ | via Lite `loadGltf` / `loadBabylon` |
146
- | `SceneLoader` (`ImportMeshAsync` / `AppendAsync` / `LoadAssetContainerAsync`), `AssetsManager` | ⚡ | `AssetContainer` partial |
143
+ | Feature area | Status | Notes |
144
+ | ---------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------------------------------------------------- |
145
+ | glTF 2.0 (+ extensions), `.babylon` | ✅ | via Lite `loadGltf` / `loadBabylon` |
146
+ | OpenPBR glTF material adapter | ❌ | exported at root and under `GLTF2`; throws because Lite has no OpenPBR material subsystem |
147
+ | `SceneLoader` (`ImportMeshAsync` / `AppendAsync` / `LoadAssetContainerAsync`), `AssetsManager` | ⚡ | `AssetContainer` partial |
147
148
  | Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ | via `GaussianSplattingMesh`; LOD-streaming + glTF-embedded (`KHR_gaussian_splatting`) variants unsupported |
148
- | `OBJ` / `STL` / `FBX` / `BVH` | ❌ | not in Lite — convert to glTF |
149
+ | `OBJ` / `STL` / `FBX` / `BVH` | ❌ | not in Lite — convert to glTF |
149
150
 
150
151
  ### `@babylonjs/addons` · `@recast-navigation/*`
151
152
 
package/index.d.ts CHANGED
@@ -203,20 +203,16 @@ export declare abstract class AbstractEngine {
203
203
  beginFrame(): never;
204
204
  /** Babylon.js manual frame-pump exit point — unsupported (Lite's frame graph owns the frame). */
205
205
  endFrame(): never;
206
+ /** Babylon.js `engine.currentSampleCount` — the active surface's MSAA sample count. */
207
+ get currentSampleCount(): number;
206
208
  /**
207
- * Babylon.js `engine.currentSampleCount` — the MSAA sample count of the current render target.
208
- * Babylon Lite manages MSAA internally and exposes no public sample-count accessor, so this
209
- * needs a tree-shakeable Lite core addition before it can report a real value.
210
- */
211
- get currentSampleCount(): never;
212
- /**
213
- * Babylon.js `engine.getAlphaToCoverage()` — alpha-to-coverage state. Babylon Lite does not
214
- * expose an engine-level alpha-to-coverage toggle, so this is unsupported.
209
+ * Babylon.js `engine.getAlphaToCoverage()` — alpha-to-coverage state. Lite's API is scoped to
210
+ * individual material/sprite/text pipeline owners, not the engine-wide state BJS exposes.
215
211
  */
216
212
  getAlphaToCoverage(): never;
217
213
  /**
218
- * Babylon.js `engine.setAlphaToCoverage(enable)` — toggle alpha-to-coverage. Babylon Lite does
219
- * not expose an engine-level alpha-to-coverage toggle, so this is unsupported.
214
+ * Babylon.js `engine.setAlphaToCoverage(enable)` — toggle alpha-to-coverage. Lite's target-
215
+ * scoped API cannot reproduce the engine-wide state without a pipeline-owner lifecycle policy.
220
216
  */
221
217
  setAlphaToCoverage(_enable: boolean): never;
222
218
  /**
@@ -762,8 +758,11 @@ export declare const AnimationTypes: {
762
758
  readonly ANIMATIONTYPE_COLOR4: 6;
763
759
  };
764
760
 
761
+ export declare interface AppendOptions extends ISceneLoaderOptions {
762
+ }
763
+
765
764
  /** Babylon.js `AppendSceneAsync(source, scene, options?)` — appends an asset's contents to the scene. */
766
- export declare function AppendSceneAsync(source: string, scene: Scene, _options?: unknown): Promise<Scene>;
765
+ export declare function AppendSceneAsync(source: string, scene: Scene, options?: AppendOptions): Promise<Scene>;
767
766
 
768
767
  export declare class ArcRotateCamera extends Camera {
769
768
  constructor(name: string, alpha: number, beta: number, radius: number, target: Vector3, scene?: Scene);
770
769
  getClassName(): string;
771
770
  get alpha(): number;
@@ -990,6 +989,10 @@ export declare class BackgroundMaterial {
990
989
  constructor();
991
990
  }
992
991
 
992
+ export declare class BallAndSocketConstraint extends PhysicsConstraint {
993
+ constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
994
+ }
995
+
993
996
  export declare class BaseSixDofDragBehavior {
994
997
  constructor();
995
998
  }
@@ -1168,18 +1171,18 @@ export declare class CannonJSPlugin {
1168
1171
  constructor();
1169
1172
  }
1170
1173
 
1171
- /**
1172
- * Babylon.js `CascadedShadowGenerator` — cascaded shadow maps for large directional
1173
- * scenes. Mapped onto Babylon Lite's CSM generator is a larger task; for now this
1174
- * extends {@link ShadowGenerator} and falls back to the standard directional path,
1175
- * which renders (a single cascade's worth of) shadows rather than throwing.
1176
- */
1174
+ /** Babylon.js `CascadedShadowGenerator` backed by Lite's native CSM generator. */
1177
1175
  export declare class CascadedShadowGenerator extends ShadowGenerator {
1178
- numCascades: number;
1176
+ private _numCascades;
1179
1177
  lambda: number;
1178
+ cascadeBlendPercentage: number;
1180
1179
  stabilizeCascades: boolean;
1180
+ shadowMaxZ: number | undefined;
1181
1181
  depthClamp: boolean;
1182
1182
  autoCalcDepthBounds: boolean;
1183
+ constructor(mapSize: number, light: DirectionalLight);
1184
+ get numCascades(): number;
1185
+ set numCascades(value: number);
1183
1186
  getClassName(): string;
1184
1187
  }
1185
1188
 
@@ -1630,6 +1633,10 @@ export declare class DirectionalLight extends Light {
1630
1633
  constructor(name: stri
1631
1634
  set specular(value: Color3);
1632
1635
  }
1633
1636
 
1637
+ export declare class DistanceConstraint extends PhysicsConstraint {
1638
+ constructor(maxDistance: number, scene: Scene);
1639
+ }
1640
+
1634
1641
  /**
1635
1642
  * Babylon.js `DynamicTexture` — a canvas-backed texture. Draw into
1636
1643
  * `getContext()`, then call `update()` to upload the canvas pixels to the GPU.
@@ -1746,7 +1753,9 @@ export declare class FBXFileLoader {
1746
1753
  }
1747
1754
 
1748
1755
  /** Babylon.js `FlyCamera` — 6-DOF free-flight camera. */
1749
- export declare class FlyCamera extends TargetCamera {
1756
+ export declare class FlyCamera extends TargetCamera {
1750
1757
  constructor(name: string, position: Vector3, scene?: Scene);
1758
+ get upVector(): Vector3;
1759
+ set upVector(value: Vector3);
1751
1760
  getClassName(): string;
1752
1761
  }
1753
1762
 
@@ -1941,6 +1950,12 @@ export declare class GlowLayer {
1941
1950
  constructor();
1942
1951
  }
1943
1952
 
1953
+ export declare namespace GLTF2 {
1954
+ export {
1955
+ OpenPBRMaterialLoadingAdapter
1956
+ }
1957
+ }
1958
+
1944
1959
  export declare class GPUParticleSystem {
1945
1960
  constructor();
1946
1961
  }
@@ -2219,6 +2234,12 @@ export declare class HighlightLayer {
2219
2234
  constructor();
2220
2235
  }
2221
2236
 
2237
+ /** Babylon.js `HingeConstraint` adapter. */
2238
+ export declare class HingeConstraint extends PhysicsConstraint {
2239
+ constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
2240
+ getClassName(): string;
2241
+ }
2242
+
2222
2243
  export declare class HtmlInteractionManager {
2223
2244
  constructor();
2224
2245
  }
@@ -2393,7 +2414,11 @@ export declare interface IMainAudioBusOptions extends Partial<IVolumeAudioOption
2393
2414
  }
2394
2415
 
2395
2416
  /** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
2396
- export declare function ImportMeshAsync(source: string, scene: Scene, _options?: unknown): Promise<ImportResult>;
2417
+ export declare function ImportMeshAsync(source: string, scene: Scene, options?: ImportMeshOptions): Promise<ImportResult>;
2418
+
2419
+ export declare interface ImportMeshOptions extends ISceneLoaderOptions {
2420
+ meshNames?: string | readonly string[] | null;
2421
+ }
2397
2422
 
2398
2423
  declare interface ImportResult {
2399
2424
  meshes: TransformNode[];
@@ -2442,6 +2467,25 @@ export declare interface ISafeOrbitCameraLimits {
2442
2467
  elevationMinMax?: [number, number];
2443
2468
  }
2444
2469
 
2470
+ export declare interface ISceneLoaderOptions {
2471
+ rootUrl?: string;
2472
+ onProgress?: (event: ISceneLoaderProgressEvent) => void;
2473
+ pluginExtension?: string;
2474
+ name?: string;
2475
+ pluginOptions?: Record<string, unknown> & {
2476
+ gltf?: {
2477
+ preprocessUrlAsync?: (url: string) => Promise<string>;
2478
+ [option: string]: unknown;
2479
+ };
2480
+ };
2481
+ }
2482
+
2483
+ export declare interface ISceneLoaderProgressEvent {
2484
+ lengthComputable: boolean;
2485
+ loaded: number;
2486
+ total: number;
2487
+ }
2488
+
2445
2489
  /** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
2446
2490
  export declare function IsHtmlInCanvasSupportedNatively(): never;
2447
2491
 
@@ -2703,7 +2747,10 @@ export declare class LiteCompatError extends Error {
2703
2747
  }
2704
2748
 
2705
2749
  /** Babylon.js `LoadAssetContainerAsync(source, scene, options?)` — loads into a container without adding. */
2706
- export declare function LoadAssetContainerAsync(source: string, scene: Scene, _options?: unknown): Promise<AssetContainer>;
2750
+ export declare function LoadAssetContainerAsync(source: string, scene: Scene, options?: LoadAssetContainerOptions): Promise<AssetContainer>;
2751
+
2752
+ export declare interface LoadAssetContainerOptions extends ISceneLoaderOptions {
2753
+ }
2707
2754
 
2708
2755
  /**
2709
2756
  * Babylon.js `LoadImageToTexture2DArrayLayerAsync` — fetch/decode an image URL and
@@ -2711,6 +2758,10 @@ export declare function LoadAssetContainerAsync(source: string, scene: Scene, _o
2711
2758
  */
2712
2759
  export declare function LoadImageToTexture2DArrayLayerAsync(texture: RawTexture2DArray, url: string, layer: number, options?: IUploadImageToTexture2DArrayLayerOptions): Promise<void>;
2713
2760
 
2761
+ export declare class LockConstraint extends PhysicsConstraint {
2762
+ constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
2763
+ }
2764
+
2714
2765
  declare interface LockedTarget {
2715
2766
  position: {
2716
2767
  x: number;
@@ -2993,19 +3044,6 @@ export declare class MorphTargetManager {
2993
3044
  private readonly _targets;
2994
3045
  /** Babylon.js `MorphTargetManager.addTarget(target)`. */
2995
3046
  addTarget(target: MorphTarget): void;
2996
3047
 
2997
- /**
2998
- * Stubs for Babylon.js core/loader APIs that are **known but not supported** by
2999
- * Babylon Lite.
3000
- *
3001
- * Every entry here throws {@link LiteCompatError} on use (construction or call),
3002
- * so a ported scene fails loudly with a clear pointer instead of either a
3003
- * confusing "X is not exported from the compat package" error or, worse, a
3004
- * silently-wrong render. These mirror the `❌ Not supported` /
3005
- * `⛔ Out of scope` rows in `COMPAT-STATUS.md`.
3006
- *
3007
- * As Babylon Lite gains a capability, the corresponding stub here should be
3008
- * replaced by a real wrapper (and its `COMPAT-STATUS.md` row upgraded).
3009
- */
3010
3048
  export declare class MultiMaterial {
3011
3049
  constructor();
3012
3050
  }
@@ -3183,6 +3221,21 @@ declare type ObserverCallback<T> = (eventData: T) => void;
3183
3221
  /** Babylon.js `OnAudioEngineV2CreatedObservable` — fires when an engine is created. */
3184
3222
  export declare const OnAudioEngineV2CreatedObservable: Observable<AudioEngineV2>;
3185
3223
 
3224
+ export declare class OpenPBRMaterial extends PushMaterial {
3186
3225
  constructor(_name: string, _scene?: Scene, _forceGLSL?: boolean);
3226
+ clone(_name: string, _cloneTexturesOnlyOnce?: boolean, _rootUrl?: string): OpenPBRMaterial;
3227
+ }
3228
+
3229
+ export declare class OpenPBRMaterialDefines {
3230
+ constructor(_externalProperties?: Record<string, {
3231
+ type: string;
3232
+ default: unknown;
3233
+ }>);
3234
+ }
3235
+
3236
+ export declare class OpenPBRMaterialLoadingAdapter {
3237
+ constructor(_material: Material);
3238
+ }
3239
+
3187
3240
  export declare class OutlineRenderer {
3188
3241
  constructor();
3189
3242
  }
@@ -3499,6 +3552,19 @@ export declare class PerformanceMonitor {
3499
3552
  reset(): void;
3500
3553
  }
3501
3554
 
3555
+ export declare class Physics6DoFConstraint extends PhysicsConstraint {
3556
+ readonly limits: Physics6DoFLimit[];
3557
+ constructor(constraintParams: PhysicsConstraintParameters, limits: Physics6DoFLimit[], scene: Scene);
3558
+ }
3559
+
3560
+ export declare class Physics6DoFLimit {
3561
+ axis: PhysicsConstraintAxis;
3562
+ minLimit?: number;
3563
+ maxLimit?: number;
3564
+ stiffness?: number;
3565
+ damping?: number;
3566
+ }
3567
+
3502
3568
  /** Babylon.js aggregate convenience object backed by Lite's native aggregate factory. */
3503
3569
  export declare class PhysicsAggregate {
3504
3570
  readonly transformNode: TransformNode;
@@ -3555,6 +3621,7 @@ export declare class PhysicsBody {
3555
3621
  readonly transformNode: TransformNode;
3556
3622
  getAngularVelocityToRef(result: Vector3): void;
3557
3623
  applyImpulse(impulse: Vec3Like, location: Vec3Like): void;
3558
3624
  applyForce(force: Vec3Like, location: Vec3Like): void;
3625
+ addConstraint(childBody: PhysicsBody, constraint: PhysicsConstraint): void;
3559
3626
  dispose(): void;
3560
3627
 
3561
3628
  /**
@@ -3616,6 +3683,41 @@ export declare class PhysicsCharacterController {
3616
3683
  readonly onTriggerCollisio
3617
3684
  set characterMass(value: number);
3618
3685
  }
3619
3686
 
3687
+ /** Babylon.js-shaped Physics V2 constraint backed by Lite's native constraint factory. */
3688
+ export declare class PhysicsConstraint {
3689
+ readonly type: PhysicsConstraintType;
3690
+ protected readonly _options: PhysicsConstraintParameters;
3691
+ protected readonly _scene: Scene;
3692
+ protected readonly _limits: readonly Physics6DoFLimit[];
3693
+ private readonly _lite;
3694
+ private readonly _world;
3695
+ constructor(type: PhysicsConstraintType, _options: PhysicsConstraintParameters, _scene: Scene, _limits?: readonly Physics6DoFLimit[]);
3696
+ get options(): PhysicsConstraintParameters;
3697
+ getClassName(): string;
3620
3698
  dispose(): void;
3699
+ }
3700
+
3701
+ /** Axis addressed by a Physics V2 constraint limit. */
3702
+ export declare enum PhysicsConstraintAxis {
3703
+ LINEAR_X = 0,
3704
+ LINEAR_Y = 1,
3705
+ LINEAR_Z = 2,
3706
+ ANGULAR_X = 3,
3707
+ ANGULAR_Y = 4,
3708
+ ANGULAR_Z = 5,
3709
+ LINEAR_DISTANCE = 6
3710
+ }
3711
+
3712
+ export declare interface PhysicsConstraintParameters {
3713
+ pivotA?: Vec3Like;
3714
+ pivotB?: Vec3Like;
3715
+ axisA?: Vec3Like;
3716
+ axisB?: Vec3Like;
3717
+ perpAxisA?: Vec3Like;
3718
+ perpAxisB?: Vec3Like;
3719
+ maxDistance?: number;
3720
+ collision?: boolean;
3721
+ }
3722
+
3621
3723
  /** Type of a Physics V2 constraint. Values match Babylon.js `PhysicsConstraintType`. */
3622
3724
  export declare enum PhysicsConstraintType {
3623
3725
  BALL_AND_SOCKET = 1,
@@ -3876,6 +3978,10 @@ export declare class PredicateCondition extends Condition {
3876
3978
  /** A bus a sound or bus can output to (mirrors AudioV2 `PrimaryAudioBus`). */
3877
3979
  export declare type PrimaryAudioBus = MainAudioBus | AudioBus;
3878
3980
 
3981
+ export declare class PrismaticConstraint extends PhysicsConstraint {
3982
+ constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
3983
+ }
3984
+
3879
3985
  /** Babylon.js `PushMaterial` — intermediate base; behaves like {@link Material} here. */
3880
3986
  export declare abstract class PushMaterial extends Material {
3881
3987
  getClassName(): string;
@@ -4067,6 +4173,8 @@ export declare class ReflectionProbe {
4067
4173
 
4068
4174
  export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
4069
4175
 
4176
+ export declare function RegisterOpenpbrMaterial(): void;
4177
+
4070
4178
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
4071
4179
  export declare class RenderTargetTexture {
4072
4180
  constructor();
@@ -4455,6 +4563,10 @@ export declare class Skeleton {
4455
4563
  getBoneByName(name: string): Bone | null;
4456
4564
  }
4457
4565
 
4566
+ export declare class SliderConstraint extends PhysicsConstraint {
4567
+ constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
4568
+ }
4569
+
4458
4570
  /**
4459
4571
  * Babylon.js-compatible Misc utilities — the pure-JS subset that has no Babylon
4460
4572
  * Lite or GPU dependency: `SmartArray`, `StringDictionary`, `Tags`,
@@ -4603,6 +4715,10 @@ export declare class SpotLight extends Light {
4603
4715
  constructor(name: string, pos
4604
4716
  set specular(value: Color3);
4605
4717
  }
4606
4718
 
4719
+ export declare class SpringConstraint extends Physics6DoFConstraint {
4720
+ constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, minDistance: number, maxDistance: number, stiffness: number, damping: number, scene: Scene);
4721
+ }
4722
+
4607
4723
  /**
4608
4724
  * Babylon.js `Sprite` — a single camera-facing billboard in a `SpriteManager`'s
4609
4725
  * atlas. World-space position + size; cell index selects the atlas frame.