@babylonjs/lite-compat 1.31.1-preview → 1.33.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
@@ -119,17 +119,17 @@ overloads within a supported area may still be absent.
119
119
  | ----------------------------------------------------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
120
120
  | Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`, color temperature/white balance) | ✅ | `Angle` / `Curve3` / `Path3D` partial |
121
121
  | Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; `currentSampleCount` reports the active surface's MSAA count; `beginFrame`/`endFrame`, occlusion queries, engine-wide alpha-to-coverage, and manual `scene.render()` unsupported |
122
- | Compute + GPU buffers (`ComputeShader`, `StorageBuffer`, `UniformBuffer`) | ⚡ | WGSL compute, direct/indirect dispatch, storage buffers, and compute-oriented std140 uniform buffers forward to Lite; shader registries/preprocessing, texture bindings, in-frame immediate dispatch, and Effect-oriented UBO methods remain unsupported |
123
- | Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` forwards to Lite's CPU/AABB picker; triangle-level positions, normals, and UVs still require async `GPUPicker`; `scene.meshes` + `getMeshBy*`/`getNodeBy*` enumerate every mesh via a canonical wrapper registry; exposure/contrast/tone mapping are forwarded, while white balance and fluid rendering throw because Lite lacks their cross-cutting shader/render-pass subsystems |
122
+ | Compute + GPU buffers (`ComputeShader`, `StorageBuffer`, `UniformBuffer`) | ⚡ | WGSL compute, direct/indirect dispatch, storage buffers, and compute-oriented std140 uniform buffers forward to Lite; shader registries/preprocessing, texture bindings, in-frame immediate dispatch, and Effect-oriented UBO methods remain unsupported |
123
+ | Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` forwards to Lite's CPU triangle picker with thin-instance, predicate, normal, and UV detail; actively deformed meshes still require async `GPUPicker`; `scene.meshes` + `getMeshBy*`/`getNodeBy*` enumerate every mesh via a canonical wrapper registry; exposure/contrast/tone mapping are forwarded, while white balance and fluid rendering throw because Lite lacks their cross-cutting shader/render-pass subsystems |
124
124
  | Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | arc controls include pointer, wheel, touch, and BJS-default Arrow-key input; orthographic bounds and projection-mode switching forward to Lite; fully unconfigured orthographic extents use Lite's `halfHeight` + aspect-ratio derivation rather than Babylon.js render dimensions; XR / device-orientation / stereoscopic rigs unsupported |
125
125
  | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters point lights (⚡ partial); `RectAreaLight` unsupported |
126
126
  | Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM |
127
- | 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; mesh-blending tag helpers and validated mesh metadata forward to native Lite; `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
+ | 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; mesh-blending tag helpers and validated mesh metadata forward to native Lite; `MergeMeshes` bakes positions/normals/UVs and rejects unsupported attributes/animation; polygon/extruded-polygon, decal/text/tiled builders, `GreasedLine*` (thick lines), `InstancedMesh`, LOD/edges/outline, and hardware instances unsupported |
128
128
  | CSG / CSG2 | ✅ | over Lite boolean ops |
129
129
  | Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled) |
130
130
  | Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; fixed-slot custom WGSL `MaterialPluginBase` injection is supported (`#include`, regex replacement, and custom UBO/sampler hooks are not), while `DitheredTileFadeMaterialPlugin`, GLSL `ShaderMaterial`, `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` remain unsupported |
131
- | Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `CubeTexture`, `HDRCubeTexture`) | ⚡ | `HDRCubeTexture` routes to native `loadHdrEnvironment`; `RawTexture2DArray` supports raw bytes, image sources/URLs, and single-file KTX2 arrays; `HtmlTexture` forwards native Lite DOM capture/update; `RenderTargetTexture` / `MirrorTexture` unsupported |
132
- | Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | All standard easing classes, including `PowerEase` / `BezierCurveEase`, reuse Lite's native functional curves; `beginAnimation` / `beginDirectAnimation` delegate supported float/vector/quaternion tracks to Lite property animation; unsupported tracks use an explicit compat evaluator; structural groups remain compat-owned; loaded glTF skeletal blending supported |
131
+ | Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `CubeTexture`, `HDRCubeTexture`) | ⚡ | `HDRCubeTexture` routes to native `loadHdrEnvironment`; `RawTexture2DArray` supports raw bytes, image sources/URLs, and single-file KTX2 arrays; `RawTexture3D` supports base-level RGBA8 volumes but not mip generation; `HtmlTexture` forwards native Lite DOM capture/update; `RenderTargetTexture` / `MirrorTexture` unsupported |
132
+ | Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | All standard easing classes, including `PowerEase` / `BezierCurveEase`, reuse Lite's native functional curves; `beginAnimation` / `beginDirectAnimation` delegate supported float/vector/quaternion tracks to Lite property animation; unsupported tracks use an explicit compat evaluator; structural groups remain compat-owned; loaded glTF skeletal blending supported; root-motion analysis/controller APIs throw |
133
133
  | Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets |
134
134
  | Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
135
135
  | Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag / six-DoF / XR-oriented mesh behaviors throw |
@@ -141,16 +141,16 @@ overloads within a supported area may still be absent.
141
141
 
142
142
  ### `@babylonjs/loaders`
143
143
 
144
- | Feature area | Status | Notes |
145
- | ---------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
146
- | glTF 2.0 (+ extensions), `.babylon` | ✅ | via Lite `loadGltf` / `loadBabylon`; KHR_interactivity assets run through Lite's native flow-graph runtime |
147
- | `GLTF2.KHR_interactivity` public helpers | ⚡ | pure operation/data normalization and exporter data types are implemented; BJS FlowGraph registry/parser/export planning throws with named structural blockers |
148
- | glTF 1.0 loader and extensions | ❌ | named `GLTF1` stubs throw; Lite has no legacy parser, extension registry, or material-conversion subsystem |
149
- | OpenPBR glTF material adapter | ❌ | exported at root and under `GLTF2`; throws because Lite has no OpenPBR material subsystem |
150
- | OpenUSD (`USDFileLoader`) | ❌ | named stub; requires a WebAssembly worker and a USD-to-Lite scene/material materializer |
151
- | `SceneLoader` (`ImportMeshAsync` / `AppendAsync` / `LoadAssetContainerAsync`), `AssetsManager` | ⚡ | `AssetContainer` partial |
152
- | Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ | via `GaussianSplattingMesh`; LOD-streaming + glTF-embedded (`KHR_gaussian_splatting`) variants unsupported |
153
- | `OBJ` / `STL` / `FBX` / `BVH` | ❌ | parser/materializer subsystems are not in Lite — convert to glTF |
144
+ | Feature area | Status | Notes |
145
+ | ---------------------------------------------------------------------------------------------- | :----: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
146
+ | glTF 2.0 (+ extensions), `.babylon` | ✅ | via Lite `loadGltf` / `loadBabylon`; KHR_interactivity assets run through Lite's native flow-graph runtime |
147
+ | `GLTF2.KHR_interactivity` public helpers | ⚡ | pure operation/data normalization and exporter data types are implemented; BJS FlowGraph registry/parser/export planning throws with named structural blockers |
148
+ | glTF 1.0 loader and extensions | ❌ | named `GLTF1` stubs throw; Lite has no legacy parser, extension registry, or material-conversion subsystem |
149
+ | OpenPBR glTF material adapter | ❌ | exported at root and under `GLTF2`; throws because Lite has no OpenPBR material subsystem |
150
+ | OpenUSD (`USDFileLoader`) | ⚡ | delegates binary import, virtual files, callbacks, diagnostics, asset containers, and disposal to Lite; all four custom runtime assets must share one directory |
151
+ | `SceneLoader` (`ImportMeshAsync` / `AppendAsync` / `LoadAssetContainerAsync`), `AssetsManager` | ⚡ | `AssetContainer` partial |
152
+ | Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ | via `GaussianSplattingMesh` and the binary-data `SPLATFileLoader` plugin surface; detached containers, unpackaged/streaming SOG, replaceable decoder policies, and full glTF-embedded (`KHR_gaussian_splatting`) variants remain unsupported |
153
+ | `OBJ` / `STL` / `FBX` / `BVH` | ❌ | parser/materializer subsystems are not in Lite — convert to glTF |
154
154
 
155
155
  ### `@babylonjs/addons` · `@recast-navigation/*`
156
156
 
package/index.d.ts CHANGED
@@ -22,6 +22,8 @@ import { StorageBuffer as StorageBuffer_2 } from '@babylonjs/lite';
22
22
  import { Texture2D } from '@babylonjs/lite';
23
23
  import { Texture2DArray } from '@babylonjs/lite';
24
24
  import { UniformBuffer as UniformBuffer_2 } from '@babylonjs/lite';
25
+ import { UsdDiagnostics } from '@babylonjs/lite';
26
+ import { UsdProgress } from '@babylonjs/lite';
25
27
 
26
28
  /** Base class for an asset-loading task. Subclasses implement {@link runAsync}. */
27
29
  export declare abstract class AbstractAssetTask {
@@ -826,7 +828,9 @@ export declare class ArcRotateCamera extends Camera {
826
828
  constructor(name: stri
827
829
  set panningSensibility(value: number);
828
830
  attachControl(canvas: HTMLCanvasElement, noPreventDefault?: boolean): void;
829
831
 
830
- export declare class AssetContainer {
831
832
  constructor(lite: AssetContainer_2);
833
+ export declare class AssetContainer {
832
834
  private readonly _dispose;
833
835
  private _sceneDisposeObserver;
836
+ private _disposed;
837
+ constructor(lite: AssetContainer_2, dispose?: () => void, ownedMeshes?: readonly Mesh_2[]);
834
838
  get animationGroups(): AnimationGroup_2[];
835
839
  /**
836
840
  * Flat list of the loaded meshes as canonical, stable-identity compat `Mesh`
@@ -837,8 +841,10 @@ export declare class AssetContainer {
837
841
  constructor(lite: AssetContainer_2);
838
842
  get meshes(): Mesh[];
839
843
  get skeletons(): Skeleton[];
840
844
  /** Add every entity, animation group, camera, and clear colour to the scene. */
841
- addAllToScene(scene: Scene): void;
842
- dispose(): void;
845
+ addAllToScene(scene: Scene): void;
843
846
  dispose(): void;
847
+ private _detachFromScene;
848
+ private _retireMeshWrappers;
849
+ private _disposeOnce;
844
850
  }
845
851
 
846
852
  export declare class AssetsManager {
@@ -1580,6 +1586,12 @@ export declare function CreateMicrophoneSoundSourceAsync(name: string, options?:
1580
1586
  /** Babylon.js `CreatePlane(name, options, scene)` (planeBuilder). */
1581
1587
  export declare function CreatePlane(name: string, options: PlaneOptions, scene: Scene): Mesh;
1582
1588
 
1589
+ /** Babylon.js `CreatePolygon(name, options, scene?, earcutInjection?)` — throwing stub (see `MeshBuilder.CreatePolygon`). */
1590
+ export declare function CreatePolygon(name: string, options: PolygonBuilderOptions, scene?: Scene | null, earcutInjection?: unknown): never;
1591
+
1592
+ /** Babylon.js `CreatePolygonVertexData` — the polygon geometry generator requires the unsupported polygon subsystem. */
1593
+ export declare function CreatePolygonVertexData(_polygon: Mesh, _sideOrientation: number, _faceUV?: Vector4[], _faceColors?: Color4[], _frontUVs?: Vector4, _backUVs?: Vector4, _wrap?: boolean): never;
1594
+
1583
1595
  /** Babylon.js `CreateSoundAsync`. */
1584
1596
  export declare function CreateSoundAsync(name: string, source: StaticSoundSource, options?: Partial<IStaticSoundOptions>, engine?: AudioEngineV2 | null): Promise<StaticSound>;
1585
1597
 
@@ -1934,6 +1946,9 @@ export declare class ExponentialEase extends EasingFunction {
1934
1946
  easeInCore(gradient: number): number;
1935
1947
  }
1936
1948
 
1949
+ /** Babylon.js `ExtrudePolygon(name, options, scene?, earcutInjection?)` — throwing stub (see `MeshBuilder.ExtrudePolygon`). */
1950
+ export declare function ExtrudePolygon(name: string, options: PolygonBuilderOptions, scene?: Scene | null, earcutInjection?: unknown): never;
1951
+
1937
1952
  /** A gradient value bound to a [0, 1] position (Babylon.js `FactorGradient`). */
1938
1953
  export declare class FactorGradient {
1939
1954
  gradient: number;
@@ -3031,6 +3046,22 @@ export declare interface IRaycastQuery {
3031
3046
  ignoreBody?: PhysicsBody;
3032
3047
  }
3033
3048
 
3049
+ export declare interface IRootMotionClipOptions {
3050
+ rootNode?: TransformNode | Bone;
3051
+ characterNode?: TransformNode;
3052
+ contactNodes?: Array<TransformNode | Bone>;
3053
+ source?: RootMotionSource;
3054
+ extractRotation?: boolean;
3055
+ samplesPerSecond?: number;
3056
+ minimumTravel?: number;
3057
+ minimumTurn?: number;
3058
+ directionSnapAngle?: number;
3059
+ extractLateralMotion?: boolean;
3060
+ upAxis?: Vector3;
3061
+ name?: string;
3062
+ cloneAnimations?: boolean;
3063
+ }
3064
+
3034
3065
  /**
3035
3066
  * Babylon.js `ISafeOrbitCameraLimits` — safe-orbit camera limits embedded in a Gaussian
3036
3067
  * Splatting file's metadata (Adobe safe-orbit extension). Exposed on the loaded mesh via
@@ -3053,6 +3084,8 @@ export declare interface ISceneLoaderOptions {
3053
3084
  preprocessUrlAsync?: (url: string) => Promise<string>;
3054
3085
  [option: string]: unknown;
3055
3086
  };
3087
+ splat?: Partial<Readonly<SPLATLoadingOptions>>;
3088
+ usd?: Partial<USDFileLoaderOptions>;
3056
3089
  };
3057
3090
  }
3058
3091
 
@@ -3564,6 +3597,10 @@ export declare class Mesh extends AbstractMesh {
3564
3597
  static CreateCylinder(name: string, height: number, diameterTop: number, diameterBottom: number, tessellation: number, _subdivisions: number, scene: Scene): Mesh;
3565
3598
  /** Legacy `Mesh.CreateTorus(name, diameter, thickness, tessellation, scene)`. */
3566
3599
  static CreateTorus(name: string, diameter: number, thickness: number, tessellation: number, scene: Scene): Mesh;
3600
+ /** Legacy `Mesh.CreatePolygon(name, shape, scene, holes?, updatable?, sideOrientation?, earcutInjection?)`. */
3601
+ static CreatePolygon(_name: string, _shape: Vector3[], _scene: Scene, _holes?: Vector3[][], _updatable?: boolean, _sideOrientation?: number, _earcutInjection?: unknown): never;
3602
+ /** Legacy `Mesh.ExtrudePolygon(name, shape, depth, scene, holes?, updatable?, sideOrientation?, earcutInjection?)`. */
3603
+ static ExtrudePolygon(_name: string, _shape: Vector3[], _depth: number, _scene: Scene, _holes?: Vector3[][], _updatable?: boolean, _sideOrientation?: number, _earcutInjection?: unknown): never;
3567
3604
  /** Hardware-instanced copy — unsupported. Use native thin instances instead. */
3568
3605
  createInstance(): never;
3569
3606
  /**
@@ -3682,11 +3719,13 @@ export declare const MeshBuilder: {
3682
3719
  CreateText(): never;
3683
3720
  CreateTiledBox(_name?: string, _options?: object, _scene?: Scene): never;
3684
3721
  CreateTiledPlane(_name?: string, _options?: object, _scene?: Scene): never;
3722
+ CreatePolygon(_name: string, _options: PolygonBuilderOptions, _scene?: Scene | null, _earcutInjection?: unknown): never;
3723
+ ExtrudePolygon(_name: string, _options: PolygonBuilderOptions, _scene?: Scene | null, _earcutInjection?: unknown): never;
3685
3724
  };
3686
3725
 
3687
3726
  /** A compat mesh exposes its backing Lite mesh as `_lite`. */
3688
3727
  declare interface MeshLike {
3689
- _lite: Mesh_2;
3728
+ _lite: Mesh;
3690
3729
  }
3691
3730
 
3692
3731
  /**
@@ -3716,6 +3755,8 @@ export declare class MeshoptCompression {
3716
3755
  static get Default(): MeshoptCompression;
3717
3756
  }
3718
3757
 
3758
+ export declare type MeshPredicate = (mesh: AbstractMesh, thinInstanceIndex: number) => boolean;
3759
+
3719
3760
  export { MinTemperatureKelvin }
3720
3761
 
3721
3762
  export declare class MirrorTexture {
@@ -3918,8 +3959,7 @@ export declare class Observable<T> {
3918
3959
  addOnce(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
3919
3960
  remove(callback: ObserverCallback<T> | null | undefined): boolean;
3920
3961
  removeCallback(callback: ObserverCallback<T>): boolean;
3921
- notifyObservers(eventData?: T, mask?: number): void;
3922
- hasObservers(): boolean;
3962
+ notifyObservers(eventData?: T, mask?: number): void;
3923
3963
  hasObservers(): boolean;
3924
3964
  clear(): void;
3925
3965
  cleanLastNotifiedState(): void;
3926
3966
  }
@@ -4560,8 +4600,11 @@ export declare class PickingInfo {
4560
4600
  aimTransform: TransformNode | null;
4561
4601
  gripTransform: TransformNode | null;
4562
4602
  private _normal;
4563
- private _worldNormal;
4564
4603
  getNormal(useWorldCoordinates?: boolean, _useVerticesNormals?: boolean): Vector3 | null;
4565
- getTextureCoordinates(_uvSet?: string): Vector2 | null;
4604
+ private _worldNormal;
4605
+ private _faceNormal;
4606
+ private _faceWorldNormal;
4607
+ private _uv;
4566
4608
  getNormal(useWorldCoordinates?: boolean, useVerticesNormals?: boolean): Vector3 | null;
4609
+ getTextureCoordinates(uvSet?: string): Vector2 | null;
4567
4610
  }
4568
4611
 
4569
4612
  declare type PickListItem = PickableMesh | {
@@ -4695,6 +4738,26 @@ export declare class Polar {
4695
4738
  static FromArray(array: number[]): Polar;
4696
4739
  }
4697
4740
 
4741
+ /** Babylon.js polygon-builder namespace object. */
4742
+ export declare const PolygonBuilder: {
4743
+ ExtrudePolygon: typeof ExtrudePolygon;
4744
+ CreatePolygon: typeof CreatePolygon;
4745
+ };
4746
+
4747
+ declare interface PolygonBuilderOptions {
4748
+ shape: Vector3[];
4749
+ holes?: Vector3[][];
4750
+ depth?: number;
4751
+ smoothingThreshold?: number;
4752
+ faceUV?: Vector4[];
4753
+ faceColors?: Color4[];
4754
+ updatable?: boolean;
4755
+ sideOrientation?: number;
4756
+ frontUVs?: Vector4;
4757
+ backUVs?: Vector4;
4758
+ wrap?: boolean;
4759
+ }
4760
+
4698
4761
  export declare class PositionGizmo extends GizmoBase {
4699
4762
  private _attached;
4700
4763
  private _xGizmo;
4701
4764
  private _yGizmo;
@@ -4898,7 +4961,7 @@ export declare class RawTexture3D extends BaseTexture {
4898
4961
  readonly is3D = true;
4899
4962
  constructor(data: ArrayBufferView | null, width: number, height: number, depth: number,
4900
4963
  /** Babylon.js texture format (recorded for parity; Lite uploads RGBA8). */
4901
- format: number, scene: Scene, _generateMipMaps?: boolean, _invertY?: boolean, _samplingMode?: number, _textureType?: number, _creationFlags?: number);
4964
+ format: number, scene: Scene, generateMipMaps?: boolean, _invertY?: boolean, _samplingMode?: number, _textureType?: number, _creationFlags?: number);
4902
4965
  getClassName(): string;
4903
4966
  /** Gets the width of the texture. */
4904
4967
  get width(): number;
@@ -4972,13 +5035,66 @@ export declare function RegisterMeshBlendingPostProcessBlock(): never;
4972
5035
 
4973
5036
  export declare function RegisterOpenpbrMaterial(): void;
4974
5037
 
4975
- export declare function RegisterUSDFileLoader(): never;
5038
+ /**
5039
+ * Babylon.js side-effect registration shim. Compat defines the corresponding
5040
+ * methods directly, so importing or calling this function requires no mutation.
5041
+ */
5042
+ export declare function RegisterPolygonBuilder(): void;
5043
+
5044
+ export declare function RegisterSPLATFileLoader(): void;
5045
+
5046
+ export declare function RegisterUSDFileLoader(): void;
4976
5047
 
4977
5048
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
4978
5049
  export declare class RenderTargetTexture {
4979
5050
  constructor();
4980
5051
  }
4981
5052
 
5053
+ export declare class RootMotionClip {
5054
+ constructor(_animationGroup: AnimationGroup, _options?: IRootMotionClipOptions);
5055
+ get sourceAnimationGroup(): AnimationGroup;
5056
+ get animationGroup(): AnimationGroup;
5057
+ get controller(): RootMotionController | null;
5058
+ get source(): RootMotionSource;
5059
+ get rootNode(): TransformNode | null;
5060
+ get characterNode(): TransformNode;
5061
+ get contactNodes(): ReadonlyArray<TransformNode>;
5062
+ get upAxis(): Vector3;
5063
+ get fromFrame(): number;
5064
+ get toFrame(): number;
5065
+ get travelDirection(): Vector3;
5066
+ get cycleOffset(): Vector3;
5067
+ get cycleDistance(): number;
5068
+ get cycleRotation(): number;
5069
+ get extractsRotation(): boolean;
5070
+ get duration(): number;
5071
+ get averageSpeed(): number;
5072
+ get characterHeight(): number;
5073
+ getOffsetAtFrame(_frame: number, _result: Vector3): Vector3;
5074
+ getRotationAtFrame(_frame: number): number;
5075
+ dispose(): void;
5076
+ }
5077
+
5078
+ export declare class RootMotionController {
5079
+ applyToCharacter: boolean;
5080
+ readonly onRootMotionObservable: Observable<RootMotionController>;
5081
+ constructor(_characterNode: TransformNode, _clips?: RootMotionClip[]);
5082
+ get characterNode(): TransformNode;
5083
+ get clips(): ReadonlyArray<RootMotionClip>;
5084
+ get deltaPosition(): Vector3;
5085
+ get deltaRotation(): number;
5086
+ addClip(_clip: RootMotionClip): void;
5087
+ removeClip(_clip: RootMotionClip): void;
5088
+ reset(): void;
5089
+ dispose(): void;
5090
+ }
5091
+
5092
+ export declare enum RootMotionSource {
5093
+ None = 0,
5094
+ Root = 1,
5095
+ FootContact = 2
5096
+ }
5097
+
4982
5098
  export declare class RotationGizmo extends GizmoBase {
4983
5099
  private _attached;
4984
5100
  private _xGizmo;
4985
5101
  private _yGizmo;
@@ -5207,14 +5323,14 @@ export declare class Scene extends AbstractScene {
5207
5323
  /** Babylon.js fog-mode c
5208
5324
  /** Babylon.js synchronous readiness check — always ready in the compat layer. */
5209
5325
  isReady(): boolean;
5210
5326
  /** Babylon.js synchronous screen-coordinate picking over Lite's CPU ray picker. */
5211
- pick(x: number, y: number, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, camera?: Camera | null, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
5327
+ pick(x: number, y: number, predicate?: MeshPredicate, fastCheck?: boolean, camera?: Camera | null, trianglePredicate?: TrianglePickingPredicate): PickingInfo;
5212
5328
  /**
5213
5329
  * Babylon.js `Scene.createPickingRay` — translate CSS coordinates and camera
5214
5330
  * transforms into Lite's reverse-Z unprojection helper.
5215
5331
  */
5216
5332
  createPickingRay(x: number, y: number, world?: Matrix | null, camera?: Camera | null, cameraViewSpace?: boolean): Ray;
5217
5333
  /** Synchronous CPU ray picking over Babylon Lite's scene-mesh picker. */
5218
- pickWithRay(ray: Ray, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
5219
5334
  /**
5335
+ pickWithRay(ray: Ray, predicate?: MeshPredicate, fastCheck?: boolean, trianglePredicate?: TrianglePickingPredicate): PickingInfo;
5220
5336
  /**
5221
5337
  * Babylon.js `scene.enablePhysics(gravity, plugin)`. Wires the given Havok V2
5222
5338
  * {@link HavokPlugin} to this scene, creating the native Lite physics world and
5223
5339
  * registering per-frame stepping. The plugin's `useDeltaForWorldStep` flag
@@ -5532,6 +5648,60 @@ export declare class Spherical {
5532
5648
  static FromArray(array: number[]): Spherical;
5533
5649
  }
5534
5650
 
5651
+ export declare class SPLATFileLoader {
5652
+ readonly name = "splat";
5653
+ readonly extensions: {
5654
+ readonly ".splat": {
5655
+ readonly isBinary: true;
5656
+ };
5657
+ readonly ".ply": {
5658
+ readonly isBinary: true;
5659
+ };
5660
+ readonly ".spz": {
5661
+ readonly isBinary: true;
5662
+ };
5663
+ readonly ".json": {
5664
+ readonly isBinary: false;
5665
+ };
5666
+ readonly ".sog": {
5667
+ readonly isBinary: true;
5668
+ };
5669
+ };
5670
+ private readonly _loadingOptions;
5671
+ constructor(loadingOptions?: Partial<Readonly<SPLATLoadingOptions>>);
5672
+ createPlugin(options: {
5673
+ splat?: Partial<Readonly<SPLATLoadingOptions>>;
5674
+ }): SPLATFileLoader;
5675
+ importMeshAsync(_meshesNames: unknown, scene: Scene, data: unknown, _rootUrl: string, _onProgress?: (event: ISceneLoaderProgressEvent) => void, _fileName?: string): Promise<SPLATImportResult>;
5676
+ loadAsync(scene: Scene, data: unknown, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
5677
+ loadAssetContainerAsync(_scene: Scene, _data: string, _rootUrl: string): Promise<AssetContainer>;
5535
5678
  private _load;
5679
+ private _loadReserved;
5680
+ private _adoptLoaded;
5681
+ }
5682
+
5683
+ declare interface SPLATImportResult {
5684
+ meshes: GaussianSplattingMesh[];
5685
+ particleSystems: unknown[];
5686
+ skeletons: unknown[];
5687
+ animationGroups: unknown[];
5688
+ transformNodes: unknown[];
5689
+ geometries: unknown[];
5690
+ lights: unknown[];
5691
+ spriteManagers: unknown[];
5692
+ }
5693
+
5694
+ export declare type SPLATLoadingOptions = {
5695
+ keepInRam?: boolean;
5696
+ flipY?: boolean;
5697
+ deflateURL?: string;
5698
+ fflate?: unknown;
5699
+ disableAutoCameraLimits?: boolean;
5700
+ gaussianSplattingMesh?: GaussianSplattingMesh;
5701
+ needsRotationScaleTextures?: boolean;
5702
+ useSogTextures?: boolean;
5703
+ spzLibraryUrl?: string;
5704
+ };
5705
+
5536
5706
  export declare class SpotLight extends Light {
5537
5707
  constructor(name: string, position: Vector3, direction: Vector3, angle: number, exponent: number, scene?: Scene);
5538
5708
  getClassName(): string;
5539
5709
  get angle(): number;
@@ -6050,6 +6220,8 @@ export declare class TransformNode extends Node_2 {
6050
6220
  physicsBody: PhysicsBody
6051
6221
 
6052
6222
  export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
6053
6223
 
6224
+ export declare type TrianglePickingPredicate = (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray, i0: number, i1: number, i2: number) => boolean;
6225
+
6054
6226
  /** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */
6055
6227
  export declare class UniformBuffer {
6056
6228
  private readonly _engine;
@@ -6154,7 +6326,34 @@ export declare function UploadImageToTexture2DArrayLayer(texture: RawTexture2DAr
6154
6326
  export declare type USDBinaryInput = ArrayBuffer | ArrayBufferView;
6155
6327
 
6156
6328
  export declare class USDFileLoader {
6157
- constructor(_options?: Partial<USDFileLoaderOptions>);
6329
+ static get DefaultConfiguration(): Required<Pick<USDFileLoaderOptions, "workerUrl" | "glueUrl" | "wasmUrl" | "dataUrl">>;
6330
+ static set DefaultConfiguration(configuration: Required<Pick<USDFileLoaderOptions, "workerUrl" | "glueUrl" | "wasmUrl" | "dataUrl">>);
6331
+ readonly name = "usd";
6332
+ readonly extensions: {
6333
+ readonly ".usd": {
6334
+ readonly isBinary: true;
6335
+ };
6336
+ readonly ".usda": {
6337
+ readonly isBinary: true;
6338
+ };
6339
+ readonly ".usdc": {
6340
+ readonly isBinary: true;
6341
+ };
6342
+ readonly ".usdz": {
6343
+ readonly isBinary: true;
6344
+ };
6345
+ };
6346
+ private readonly _options;
6347
+ private readonly _activeLoads;
6348
+ constructor(options?: Partial<USDFileLoaderOptions>);
6349
+ createPlugin(options: {
6350
+ usd?: Partial<USDFileLoaderOptions>;
6351
+ }): USDFileLoader;
6352
+ importMeshAsync(_meshNames: string | readonly string[] | null | undefined, scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<USDImportResult>;
6353
+ loadAsync(scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
6354
+ loadAssetContainerAsync(scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<AssetContainer>;
6355
+ dispose(): void;
6356
+ private _load;
6158
6357
  }
6159
6358
 
6160
6359
  export declare interface USDFileLoaderOptions {
@@ -6170,38 +6369,24 @@ export declare interface USDFileLoaderOptions {
6170
6369
  onComplete?: (diagnostics: USDImportDiagnostics) => void;
6171
6370
  }
6172
6371
 
6173
- export declare interface USDImportDiagnostics {
6174
- timings: USDImportTimings;
6175
- statistics: USDImportStatistics;
6176
- missingAssets: readonly string[];
6177
- }
6372
+ export declare type USDImportDiagnostics = UsdDiagnostics;
6178
6373
 
6179
- export declare interface USDImportStatistics {
6180
- nodes: number;
6181
- meshes: number;
6182
- analyticPrimitives: number;
6183
- instances: number;
6184
- materials: number;
6185
- vertices: number;
6186
- triangles: number;
6187
- commandBytes: number;
6188
- dataBytes: number;
6374
+ declare interface USDImportResult {
6375
+ meshes: Mesh[];
6376
+ particleSystems: unknown[];
6377
+ skeletons: Skeleton[];
6378
+ animationGroups: AnimationGroup_2[];
6379
+ transformNodes: unknown[];
6380
+ lights: unknown[];
6189
6381
  }
6190
6382
 
6191
- export declare interface USDImportTimings {
6192
- totalMs: number;
6193
- stageOpenMs: number;
6194
- stageReadMs: number;
6195
- preparationMs: number;
6196
- packingMs: number;
6197
- heapCopyMs: number;
6198
- materializeMs: number;
6199
- }
6383
+ export declare type USDImportStatistics = UsdDiagnostics["statistics"];
6200
6384
 
6201
- export declare interface USDLoadProgress {
6202
- phase: "initializing" | "staging" | "extracting" | "materializing";
6203
- message: string;
6204
- }
6385
+ export declare type USDImportTimings = UsdDiagnostics["timings"];
6386
+
6387
+ export declare type USDLoadProgress = Omit<UsdProgress, "phase"> & {
6388
+ phase: Exclude<UsdProgress["phase"], "fetching">;
6389
+ };
6205
6390
 
6206
6391
  export declare type USDVirtualFiles = Readonly<Record<string, USDBinaryInput>>;
6207
6392
 
@@ -6388,6 +6573,8 @@ export declare class VertexData {
6388
6573
  uvs: number[] | Float32Array | null;
6389
6574
  colors: number[] | Float32Array | null;
6390
6575
  indices: number[] | Uint32Array | Uint16Array | null;
6576
+ /** Deprecated Babylon.js polygon vertex-data entry point. */
6577
+ static CreatePolygon(polygon: Mesh, sideOrientation: number, faceUV?: Vector4[], faceColors?: Color4[], frontUVs?: Vector4, backUVs?: Vector4, wrap?: boolean): never;
6391
6578
  /**
6392
6579
  * Babylon.js `VertexData.applyToMesh(mesh)` — upload this CPU geometry onto a
6393
6580
  * mesh (typically one created via `new Mesh(name, scene)`). Replaces the Lite