@babylonjs/lite-compat 1.25.0-preview → 1.27.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
 
@@ -1188,6 +1191,27 @@ declare interface CellSize {
1188
1191
  height: number;
1189
1192
  }
1190
1193
 
1194
+ export declare interface CharacterShapeOptions {
1195
+ shape?: PhysicsShape;
1196
+ capsuleHeight?: number;
1197
+ capsuleRadius?: number;
1198
+ }
1199
+
1200
+ /** Contact state of a physics character against its supporting surface. */
1201
+ export declare enum CharacterSupportedState {
1202
+ UNSUPPORTED = 0,
1203
+ SLIDING = 1,
1204
+ SUPPORTED = 2
1205
+ }
1206
+
1207
+ export declare interface CharacterSurfaceInfo {
1208
+ isSurfaceDynamic: boolean;
1209
+ supportedState: CharacterSupportedState;
1210
+ averageSurfaceNormal: Vector3;
1211
+ averageSurfaceVelocity: Vector3;
1212
+ averageAngularSurfaceVelocity: Vector3;
1213
+ }
1214
+
1191
1215
  export declare const ChromaticAberrationPostProcess: new () => never;
1192
1216
 
1193
1217
  export declare class CircleEase extends EasingFunction {
@@ -1609,6 +1633,10 @@ export declare class DirectionalLight extends Light {
1609
1633
  constructor(name: stri
1610
1634
  set specular(value: Color3);
1611
1635
  }
1612
1636
 
1637
+ export declare class DistanceConstraint extends PhysicsConstraint {
1638
+ constructor(maxDistance: number, scene: Scene);
1639
+ }
1640
+
1613
1641
  /**
1614
1642
  * Babylon.js `DynamicTexture` — a canvas-backed texture. Draw into
1615
1643
  * `getContext()`, then call `update()` to upload the canvas pixels to the GPU.
@@ -1725,7 +1753,9 @@ export declare class FBXFileLoader {
1725
1753
  }
1726
1754
 
1727
1755
  /** Babylon.js `FlyCamera` — 6-DOF free-flight camera. */
1728
- export declare class FlyCamera extends TargetCamera {
1756
+ export declare class FlyCamera extends TargetCamera {
1729
1757
  constructor(name: string, position: Vector3, scene?: Scene);
1758
+ get upVector(): Vector3;
1759
+ set upVector(value: Vector3);
1730
1760
  getClassName(): string;
1731
1761
  }
1732
1762
 
@@ -1920,6 +1950,12 @@ export declare class GlowLayer {
1920
1950
  constructor();
1921
1951
  }
1922
1952
 
1953
+ export declare namespace GLTF2 {
1954
+ export {
1955
+ OpenPBRMaterialLoadingAdapter
1956
+ }
1957
+ }
1958
+
1923
1959
  export declare class GPUParticleSystem {
1924
1960
  constructor();
1925
1961
  }
@@ -2198,6 +2234,12 @@ export declare class HighlightLayer {
2198
2234
  constructor();
2199
2235
  }
2200
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
+
2201
2243
  export declare class HtmlInteractionManager {
2202
2244
  constructor();
2203
2245
  }
@@ -2277,6 +2319,13 @@ export declare interface IAudioParameterRampOptions {
2277
2319
  shape: AudioParameterRampShape;
2278
2320
  }
2279
2321
 
2322
+ export declare interface ICharacterControllerCollisionEvent {
2323
+ collider: PhysicsBody;
2324
+ colliderIndex: number;
2325
+ impulse: Vector3;
2326
+ impulsePosition: Vector3;
2327
+ }
2328
+
2280
2329
  /** Babylon.js `ICreateTexture2DArrayFromImageUrlsOptions`. */
2281
2330
  export declare interface ICreateTexture2DArrayFromImageUrlsOptions extends IUploadImageToTexture2DArrayLayerOptions {
2282
2331
  /** Generate a full mip chain (true by default). */
@@ -2365,7 +2414,11 @@ export declare interface IMainAudioBusOptions extends Partial<IVolumeAudioOption
2365
2414
  }
2366
2415
 
2367
2416
  /** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
2368
- 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
+ }
2369
2422
 
2370
2423
  declare interface ImportResult {
2371
2424
  meshes: TransformNode[];
@@ -2414,6 +2467,25 @@ export declare interface ISafeOrbitCameraLimits {
2414
2467
  elevationMinMax?: [number, number];
2415
2468
  }
2416
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
+
2417
2489
  /** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
2418
2490
  export declare function IsHtmlInCanvasSupportedNatively(): never;
2419
2491
 
@@ -2675,7 +2747,10 @@ export declare class LiteCompatError extends Error {
2675
2747
  }
2676
2748
 
2677
2749
  /** Babylon.js `LoadAssetContainerAsync(source, scene, options?)` — loads into a container without adding. */
2678
- 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
+ }
2679
2754
 
2680
2755
  /**
2681
2756
  * Babylon.js `LoadImageToTexture2DArrayLayerAsync` — fetch/decode an image URL and
@@ -2683,6 +2758,10 @@ export declare function LoadAssetContainerAsync(source: string, scene: Scene, _o
2683
2758
  */
2684
2759
  export declare function LoadImageToTexture2DArrayLayerAsync(texture: RawTexture2DArray, url: string, layer: number, options?: IUploadImageToTexture2DArrayLayerOptions): Promise<void>;
2685
2760
 
2761
+ export declare class LockConstraint extends PhysicsConstraint {
2762
+ constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
2763
+ }
2764
+
2686
2765
  declare interface LockedTarget {
2687
2766
  position: {
2688
2767
  x: number;
@@ -2965,19 +3044,6 @@ export declare class MorphTargetManager {
2965
3044
  private readonly _targets;
2966
3045
  /** Babylon.js `MorphTargetManager.addTarget(target)`. */
2967
3046
  addTarget(target: MorphTarget): void;
2968
3047
 
2969
- /**
2970
- * Stubs for Babylon.js core/loader APIs that are **known but not supported** by
2971
- * Babylon Lite.
2972
- *
2973
- * Every entry here throws {@link LiteCompatError} on use (construction or call),
2974
- * so a ported scene fails loudly with a clear pointer instead of either a
2975
- * confusing "X is not exported from the compat package" error or, worse, a
2976
- * silently-wrong render. These mirror the `❌ Not supported` /
2977
- * `⛔ Out of scope` rows in `COMPAT-STATUS.md`.
2978
- *
2979
- * As Babylon Lite gains a capability, the corresponding stub here should be
2980
- * replaced by a real wrapper (and its `COMPAT-STATUS.md` row upgraded).
2981
- */
2982
3048
  export declare class MultiMaterial {
2983
3049
  constructor();
2984
3050
  }
@@ -3155,6 +3221,21 @@ declare type ObserverCallback<T> = (eventData: T) => void;
3155
3221
  /** Babylon.js `OnAudioEngineV2CreatedObservable` — fires when an engine is created. */
3156
3222
  export declare const OnAudioEngineV2CreatedObservable: Observable<AudioEngineV2>;
3157
3223
 
3224
+ export declare class OpenPBRMaterial extends PushMaterial {
3158
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
+
3159
3240
  export declare class OutlineRenderer {
3160
3241
  constructor();
3161
3242
  }
@@ -3471,6 +3552,19 @@ export declare class PerformanceMonitor {
3471
3552
  reset(): void;
3472
3553
  }
3473
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
+
3474
3568
  /** Babylon.js aggregate convenience object backed by Lite's native aggregate factory. */
3475
3569
  export declare class PhysicsAggregate {
3476
3570
  readonly transformNode: TransformNode;
@@ -3527,8 +3621,103 @@ export declare class PhysicsBody {
3527
3621
  readonly transformNode: TransformNode;
3528
3622
  getAngularVelocityToRef(result: Vector3): void;
3529
3623
  applyImpulse(impulse: Vec3Like, location: Vec3Like): void;
3530
3624
  applyForce(force: Vec3Like, location: Vec3Like): void;
3625
+ addConstraint(childBody: PhysicsBody, constraint: PhysicsConstraint): void;
3531
3626
  dispose(): void;
3532
3627
 
3628
+ /**
3629
+ * Babylon.js-shaped character controller backed by Lite's native, tree-shakeable
3630
+ * Havok character controller.
3631
+ */
3632
+ export declare class PhysicsCharacterController {
3533
3633
  readonly onTriggerCollisionObservable: Observable<ICharacterControllerCollisionEvent>;
3634
+ private _shape;
3635
+ private _up;
3636
+ private _maxStepHeight;
3637
+ private _footOffset;
3638
+ private _disposed;
3639
+ constructor(position: Vector3, characterShapeOptions: CharacterShapeOptions, scene: Scene);
3640
+ get shape(): PhysicsShape;
3641
+ set shape(_value: PhysicsShape);
3642
+ get shapeOptions(): CharacterShapeOptions;
3643
+ setShapeOptions(options: CharacterShapeOptions, preserveFootPosition?: boolean): void;
3644
+ getPosition(): Vector3;
3645
+ setPosition(position: Vector3): void;
3646
+ getVelocity(): Vector3;
3647
+ setVelocity(velocity: Vector3): void;
3648
+ moveWithCollisions(displacement: Vector3): void;
3649
+ integrate(deltaTime: number, surfaceInfo: CharacterSurfaceInfo, gravity: Vector3): void;
3650
+ checkSupport(deltaTime: number, direction: Vector3): CharacterSurfaceInfo;
3651
+ checkSupportToRef(deltaTime: number, direction: Vector3, result: CharacterSurfaceInfo): void;
3652
+ calculateMovement(deltaTime: number, forwardWorld: Vector3, surfaceNormal: Vector3, currentVelocity: Vector3, surfaceVelocity: Vector3, desiredVelocity: Vector3, upWorld: Vector3): Vector3;
3653
+ calculateMovementToRef(deltaTime: number, forwardWorld: Vector3, surfaceNormal: Vector3, currentVelocity: Vector3, surfaceVelocity: Vector3, desiredVelocity: Vector3, upWorld: Vector3, result: Vector3): boolean;
3654
+ dispose(): void;
3655
+ get up(): Vector3;
3656
+ set up(value: Vector3);
3657
+ get maxStepHeight(): number;
3658
+ set maxStepHeight(value: number);
3659
+ get footOffset(): number;
3660
+ set footOffset(value: number);
3661
+ private _notifyCollision;
3662
+ get keepDistance(): number;
3663
+ set keepDistance(value: number);
3664
+ get keepContactTolerance(): number;
3665
+ set keepContactTolerance(value: number);
3666
+ get maxCastIterations(): number;
3667
+ set maxCastIterations(value: number);
3668
+ get penetrationRecoverySpeed(): number;
3669
+ set penetrationRecoverySpeed(value: number);
3670
+ get staticFriction(): number;
3671
+ set staticFriction(value: number);
3672
+ get dynamicFriction(): number;
3673
+ set dynamicFriction(value: number);
3674
+ get maxSlopeCosine(): number;
3675
+ set maxSlopeCosine(value: number);
3676
+ get maxCharacterSpeedForSolver(): number;
3677
+ set maxCharacterSpeedForSolver(value: number);
3678
+ get characterStrength(): number;
3679
+ set characterStrength(value: number);
3680
+ get acceleration(): number;
3681
+ set acceleration(value: number);
3682
+ get maxAcceleration(): number;
3683
+ set maxAcceleration(value: number);
3684
+ get characterMass(): number;
3685
+ set characterMass(value: number);
3686
+ }
3687
+
3688
+ /** Babylon.js-shaped Physics V2 constraint backed by Lite's native constraint factory. */
3689
+ export declare class PhysicsConstraint {
3690
+ readonly type: PhysicsConstraintType;
3691
+ protected readonly _options: PhysicsConstraintParameters;
3692
+ protected readonly _scene: Scene;
3693
+ protected readonly _limits: readonly Physics6DoFLimit[];
3694
+ private readonly _lite;
3695
+ private readonly _world;
3696
+ constructor(type: PhysicsConstraintType, _options: PhysicsConstraintParameters, _scene: Scene, _limits?: readonly Physics6DoFLimit[]);
3697
+ get options(): PhysicsConstraintParameters;
3698
+ getClassName(): string;
3534
3699
  dispose(): void;
3700
+ }
3701
+
3702
+ /** Axis addressed by a Physics V2 constraint limit. */
3703
+ export declare enum PhysicsConstraintAxis {
3704
+ LINEAR_X = 0,
3705
+ LINEAR_Y = 1,
3706
+ LINEAR_Z = 2,
3707
+ ANGULAR_X = 3,
3708
+ ANGULAR_Y = 4,
3709
+ ANGULAR_Z = 5,
3710
+ LINEAR_DISTANCE = 6
3711
+ }
3712
+
3713
+ export declare interface PhysicsConstraintParameters {
3714
+ pivotA?: Vec3Like;
3715
+ pivotB?: Vec3Like;
3716
+ axisA?: Vec3Like;
3717
+ axisB?: Vec3Like;
3718
+ perpAxisA?: Vec3Like;
3719
+ perpAxisB?: Vec3Like;
3720
+ maxDistance?: number;
3721
+ collision?: boolean;
3722
+ }
3723
+
3535
3724
  /** Type of a Physics V2 constraint. Values match Babylon.js `PhysicsConstraintType`. */
3536
3725
  export declare enum PhysicsConstraintType {
3537
3726
  BALL_AND_SOCKET = 1,
@@ -3789,6 +3978,10 @@ export declare class PredicateCondition extends Condition {
3789
3978
  /** A bus a sound or bus can output to (mirrors AudioV2 `PrimaryAudioBus`). */
3790
3979
  export declare type PrimaryAudioBus = MainAudioBus | AudioBus;
3791
3980
 
3981
+ export declare class PrismaticConstraint extends PhysicsConstraint {
3982
+ constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
3983
+ }
3984
+
3792
3985
  /** Babylon.js `PushMaterial` — intermediate base; behaves like {@link Material} here. */
3793
3986
  export declare abstract class PushMaterial extends Material {
3794
3987
  getClassName(): string;
@@ -3980,6 +4173,8 @@ export declare class ReflectionProbe {
3980
4173
 
3981
4174
  export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
3982
4175
 
4176
+ export declare function RegisterOpenpbrMaterial(): void;
4177
+
3983
4178
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
3984
4179
  export declare class RenderTargetTexture {
3985
4180
  constructor();
@@ -4368,6 +4563,10 @@ export declare class Skeleton {
4368
4563
  getBoneByName(name: string): Bone | null;
4369
4564
  }
4370
4565
 
4566
+ export declare class SliderConstraint extends PhysicsConstraint {
4567
+ constructor(pivotA: Vector3, pivotB: Vector3, axisA: Vector3, axisB: Vector3, scene: Scene);
4568
+ }
4569
+
4371
4570
  /**
4372
4571
  * Babylon.js-compatible Misc utilities — the pure-JS subset that has no Babylon
4373
4572
  * Lite or GPU dependency: `SmartArray`, `StringDictionary`, `Tags`,
@@ -4516,6 +4715,10 @@ export declare class SpotLight extends Light {
4516
4715
  constructor(name: string, pos
4517
4716
  set specular(value: Color3);
4518
4717
  }
4519
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
+
4520
4723
  /**
4521
4724
  * Babylon.js `Sprite` — a single camera-facing billboard in a `SpriteManager`'s
4522
4725
  * atlas. World-space position + size; cell index selects the atlas frame.