@babylonjs/lite-compat 1.31.0-preview → 1.32.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/index.d.ts CHANGED
@@ -3,6 +3,7 @@ import { AnisotropyProps } from '@babylonjs/lite';
3
3
  import { AssetContainer as AssetContainer_2 } from '@babylonjs/lite';
4
4
  import { AudioGraphHost } from '@babylonjs/lite';
5
5
  import { ClearCoatProps } from '@babylonjs/lite';
6
+ import { ComputeShader as ComputeShader_2 } from '@babylonjs/lite';
6
7
  import { EngineContext } from '@babylonjs/lite';
7
8
  import { EngineOptions } from '@babylonjs/lite';
8
9
  import { IridescenceProps } from '@babylonjs/lite';
@@ -17,8 +18,12 @@ import { PhysicsWorld } from '@babylonjs/lite';
17
18
  import { RenderCanvas } from '@babylonjs/lite';
18
19
  import { SceneNode } from '@babylonjs/lite';
19
20
  import { SheenProps } from '@babylonjs/lite';
21
+ import { StorageBuffer as StorageBuffer_2 } from '@babylonjs/lite';
20
22
  import { Texture2D } from '@babylonjs/lite';
21
23
  import { Texture2DArray } from '@babylonjs/lite';
24
+ import { UniformBuffer as UniformBuffer_2 } from '@babylonjs/lite';
25
+ import { UsdDiagnostics } from '@babylonjs/lite';
26
+ import { UsdProgress } from '@babylonjs/lite';
22
27
 
23
28
  /** Base class for an asset-loading task. Subclasses implement {@link runAsync}. */
24
29
  export declare abstract class AbstractAssetTask {
@@ -217,6 +222,11 @@ export declare abstract class AbstractEngine {
217
222
  * scoped API cannot reproduce the engine-wide state without a pipeline-owner lifecycle policy.
218
223
  */
219
224
  setAlphaToCoverage(_enable: boolean): never;
225
+ /**
226
+ * Babylon.js `engine.isOcclusionQueryVisible(query)` — Lite does not expose
227
+ * occlusion-query allocation, render-pass encoding, or asynchronous result state.
228
+ */
229
+ isOcclusionQueryVisible(_query: unknown): never;
220
230
  /**
221
231
  * Babylon.js `engine.updateTextureArrayLayerFromImageSource(texture, source, layer, invertY, premultiplyAlpha)`
222
232
  * — the engine extension that uploads a decoded image source into one layer of a 2D array
@@ -610,9 +620,8 @@ export declare class Angle {
610
620
  }
611
621
 
612
622
  /**
613
- * Babylon.js `Animatable` — a running animation on a target, driven per-frame on
614
- * the CPU by evaluating each `Animation`'s keyframes and writing the result onto
615
- * the target's (dotted) property path.
623
+ * Babylon.js `Animatable` facade. Supported direct-animation tracks delegate to a
624
+ * native Lite property group; unsupported tracks retain the compat CPU evaluator.
616
625
  */
617
626
  declare class Animatable_2 {
618
627
  private readonly _target;
@@ -620,16 +629,26 @@ declare class Animatable_2 {
620
629
  private readonly _from;
621
630
  private readonly _to;
622
631
  private readonly _loop;
623
- masterFrame: number;
624
- speedRatio: number;
632
+ masterFrame: number;
625
633
  private _speedRatio;
626
634
  private _paused;
627
635
  private _stopped;
628
- constructor(_target: unknown, _animations: Animation_2[], _from: number, _to: number, _loop: boolean, speedRatio: number);
629
636
  goToFrame(frame: number): void;
637
+ private readonly _nativeManager;
638
+ private readonly _fallbackAnimations;
639
+ private readonly _fallbackFrames;
640
+ private readonly _fallbackElapsedFrames;
641
+ private readonly _fallbackRepeatCounts;
642
+ private readonly _completedFallbackAnimations;
643
+ constructor(target: unknown, animations: Animation_2[], from: number, to: number, loop: boolean, speedRatio: number);
630
644
  get speedRatio(): number;
645
+ set speedRatio(value: number);
631
646
  goToFrame(frame: number): void;
632
647
  pause(): void;
633
648
  restart(): void;
634
649
  stop(): void;
635
650
  get animationStarted(): boolean;
636
- private _apply;
651
+ private _applyFallback;
652
+ private _advanceFallback;
653
+ private _resetFallbackAnimation;
654
+ private _attachLite;
655
+ private _detachLite;
637
656
  }
638
657
  export { Animatable_2 as Animatable }
639
658
 
@@ -644,16 +663,29 @@ declare class Animation_2 {
644
663
  static readonly ANIMATIONTYPE_QUATERNION: 2;
645
664
  static readonly ANIMATIONTYPE_MATRIX: 3;
646
665
  static readonly ANIMATIONTYPE_COLOR3: 4;
666
+ static readonly ANIMATIONTYPE_VECTOR2: 5;
667
+ static readonly ANIMATIONTYPE_COLOR4: 6;
647
668
  static readonly ANIMATIONLOOPMODE_RELATIVE: 0;
648
669
  static readonly ANIMATIONLOOPMODE_CYCLE: 1;
649
670
  static readonly ANIMATIONLOOPMODE_CONSTANT: 2;
650
671
  private _keys;
672
+ private _easingFunction;
651
673
  constructor(name: string, targetProperty: string, framePerSecond: number, dataType?: number, loopMode?: number);
652
674
  setKeys(keys: IAnimationKey[]): void;
653
675
  getKeys(): IAnimationKey[];
654
676
  getHighestFrame(): number;
655
- /** Linearly evaluate the animated value at `frame` (clamped to the key range). */
656
- evaluate(frame: number): number | number[];
677
+ /**
678
+ * Assigns the easing function used to transform each non-STEP segment's normalized progress.
679
+ * @param easingFunction - A Babylon.js-shaped easing object, or `null` to restore linear progress.
680
+ */
681
+ setEasingFunction(easingFunction: IEasingFunction | null): void;
682
+ /**
683
+ * Gets the easing function currently assigned to this animation.
684
+ * @returns The assigned easing object, or `null` when interpolation uses linear progress.
685
+ */
686
+ getEasingFunction(): IEasingFunction | null;
687
+ /** Evaluate the animated value at `frame`, clamped to the key range. */
688
+ evaluate(frame: number): AnimationValue;
657
689
  /** Babylon.js helper: build a one-shot float animation between two values. */
658
690
  static CreateAndStartAnimation(name: string, _target: unknown, targetProperty: string, framePerSecond: number, totalFrame: number, from: number, to: number): Animation_2;
659
691
  }
@@ -762,6 +794,8 @@ export declare const AnimationTypes: {
762
794
  readonly ANIMATIONTYPE_COLOR4: 6;
763
795
  };
764
796
 
797
+ export declare type AnimationValue = number | number[] | IAnimationVectorValue;
798
+
765
799
  export declare interface AppendOptions extends ISceneLoaderOptions {
766
800
  }
767
801
 
@@ -794,7 +828,9 @@ export declare class ArcRotateCamera extends Camera {
794
828
  constructor(name: stri
795
829
  set panningSensibility(value: number);
796
830
  attachControl(canvas: HTMLCanvasElement, noPreventDefault?: boolean): void;
797
831
 
798
- export declare class AssetContainer {
799
832
  constructor(lite: AssetContainer_2);
833
+ export declare class AssetContainer {
800
834
  private readonly _dispose;
801
835
  private _sceneDisposeObserver;
836
+ private _disposed;
837
+ constructor(lite: AssetContainer_2, dispose?: () => void, ownedMeshes?: readonly Mesh_2[]);
802
838
  get animationGroups(): AnimationGroup_2[];
803
839
  /**
804
840
  * Flat list of the loaded meshes as canonical, stable-identity compat `Mesh`
@@ -805,8 +841,10 @@ export declare class AssetContainer {
805
841
  constructor(lite: AssetContainer_2);
806
842
  get meshes(): Mesh[];
807
843
  get skeletons(): Skeleton[];
808
844
  /** Add every entity, animation group, camera, and clear colour to the scene. */
809
- addAllToScene(scene: Scene): void;
810
- dispose(): void;
845
+ addAllToScene(scene: Scene): void;
811
846
  dispose(): void;
847
+ private _detachFromScene;
848
+ private _retireMeshWrappers;
849
+ private _disposeOnce;
812
850
  }
813
851
 
814
852
  export declare class AssetsManager {
@@ -984,7 +1022,7 @@ export declare class AxisScaleGizmo extends GizmoBase {
984
1022
  private _attached;
985
1023
  }
986
1024
 
987
1025
  export declare class BackEase extends EasingFunction {
988
- private readonly amplitude;
1026
+ amplitude: number;
989
1027
  constructor(amplitude?: number);
990
1028
  easeInCore(gradient: number): number;
991
1029
  }
@@ -1020,6 +1058,18 @@ export declare interface Behavior<T> {
1020
1058
  detach(): void;
1021
1059
  }
1022
1060
 
1061
+ /**
1062
+ * Babylon.js-compatible cubic Bezier easing class.
1063
+ */
1064
+ export declare class BezierCurveEase extends EasingFunction {
1065
+ x1: number;
1066
+ y1: number;
1067
+ x2: number;
1068
+ y2: number;
1069
+ constructor(x1?: number, y1?: number, x2?: number, y2?: number);
1070
+ easeInCore(gradient: number): number;
1071
+ }
1072
+
1023
1073
  export declare const BlackAndWhitePostProcess: new () => never;
1024
1074
 
1025
1075
  export declare const BloomEffect: new () => never;
@@ -1039,8 +1089,8 @@ export declare class Bone {
1039
1089
  }
1040
1090
 
1041
1091
  export declare class BounceEase extends EasingFunction {
1042
- private readonly bounces;
1043
- private readonly bounciness;
1092
+ bounces: number;
1093
+ bounciness: number;
1044
1094
  constructor(bounces?: number, bounciness?: number);
1045
1095
  easeInCore(gradient: number): number;
1046
1096
  }
@@ -1349,6 +1399,12 @@ export declare class Color3 {
1349
1399
  static Lerp(start: Color3, end: Color3, amount: number): Color3;
1350
1400
  }
1351
1401
 
1402
+ declare interface Color3Like {
1403
+ readonly r: number;
1404
+ readonly g: number;
1405
+ readonly b: number;
1406
+ }
1407
+
1352
1408
  export declare class Color4 {
1353
1409
  r: number;
1354
1410
  g: number;
@@ -1366,6 +1422,10 @@ export declare class Color4 {
1366
1422
  static FromInts(r: number, g: number, b: number, a: number): Color4;
1367
1423
  }
1368
1424
 
1425
+ declare interface Color4Like extends Color3Like {
1426
+ readonly a: number;
1427
+ }
1428
+
1369
1429
  /** An RGBA color bound to a [0, 1] position (Babylon.js `ColorGradient`). */
1370
1430
  export declare class ColorGradient {
1371
1431
  gradient: number;
@@ -1382,9 +1442,66 @@ export declare function CompleteGreasedLineColorTable(..._args: unknown[]): neve
1382
1442
 
1383
1443
  export declare function CompleteGreasedLineWidthTable(..._args: unknown[]): never;
1384
1444
 
1445
+ export declare interface ComputeBindingLocation {
1446
+ group: number;
1447
+ binding: number;
1448
+ }
1449
+
1450
+ export declare type ComputeBindingMapping = Record<string, ComputeBindingLocation>;
1451
+
1452
+ declare type ComputeEffect = ComputeShader_2;
1453
+
1385
1454
  /** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
1386
1455
  export declare function ComputeOverlayCssTransform(): never;
1387
1456
 
1457
+ /** Babylon.js ComputeShader adapted to Lite's public buffer-backed compute graph. */
1458
+ export declare class ComputeShader {
1459
+ private readonly _engine;
1460
+ private readonly _shaderPath;
1461
+ static readonly Parse: typeof ComputeShaderParse;
1462
+ readonly uniqueId: number;
1463
+ name: string;
1464
+ fastMode: boolean;
1465
+ onCompiled: ((effect: ComputeEffect) => void) | null;
1466
+ onError: ((effect: ComputeEffect, errors: string) => void) | null;
1467
+ readonly gpuTimeInFrame: undefined;
1468
+ triggerContextRebuild: boolean;
1469
+ private readonly _source;
1470
+ private readonly _bindings;
1471
+ private _shader;
1472
+ private _bindingSet;
1473
+ private _bindingsDirty;
1474
+ private _shaderDirty;
1475
+ private _compiled;
1476
+ constructor(name: string, _engine: AbstractEngine, _shaderPath: IComputeShaderPath | string, options?: Partial<IComputeShaderOptions>);
1477
+ private readonly _options;
1478
+ get options(): IComputeShaderOptions;
1479
+ get shaderPath(): string | IComputeShaderPath;
1480
+ getClassName(): string;
1481
+ setTexture(_name: string, _texture: BaseTexture, _bindSampler?: boolean): never;
1482
+ setInternalTexture(_name: string, _texture: unknown): never;
1483
+ setStorageTexture(_name: string, _texture: BaseTexture): never;
1484
+ setExternalTexture(_name: string, _texture: unknown): never;
1485
+ setVideoTexture(_name: string, _texture: unknown): false;
1486
+ setUniformBuffer(name: string, buffer: UniformBuffer | UniformBuffer_2): void;
1487
+ setStorageBuffer(name: string, buffer: StorageBuffer | StorageBuffer_2): void;
1488
+ setTextureSampler(_name: string, _sampler: unknown): never;
1489
+ isReady(): boolean;
1490
+ dispatch(x: number, y?: number, z?: number): boolean;
1491
+ dispatchIndirect(buffer: StorageBuffer | StorageBuffer_2, offset?: number): boolean;
1492
+ dispatchWhenReady(x: number, y?: number, z?: number, delay?: number): Promise<void>;
1493
+ serialize(): Record<string, unknown>;
1494
+ private _createGraph;
1495
+ private _createShader;
1496
+ private _createBindingSet;
1497
+ private _submit;
1498
+ private _invalidateBindings;
1499
+ }
1500
+
1501
+ export declare function ComputeShaderParse(source: Record<string, unknown>, scene: {
1502
+ getEngine(): AbstractEngine;
1503
+ }, _rootUrl: string): ComputeShader;
1504
+
1388
1505
  /** Base class for action conditions. */
1389
1506
  export declare abstract class Condition {
1390
1507
  abstract isValid(): boolean;
@@ -1417,6 +1534,14 @@ export declare const Constants: {
1417
1534
  readonly TEXTURE_TRILINEAR_SAMPLINGMODE: 3;
1418
1535
  readonly TEXTUREFORMAT_RGBA: 5;
1419
1536
  readonly TEXTURETYPE_UNSIGNED_BYTE: 0;
1537
+ readonly BUFFER_CREATIONFLAG_READ: 1;
1538
+ readonly BUFFER_CREATIONFLAG_WRITE: 2;
1539
+ readonly BUFFER_CREATIONFLAG_READWRITE: 3;
1540
+ readonly BUFFER_CREATIONFLAG_UNIFORM: 4;
1541
+ readonly BUFFER_CREATIONFLAG_VERTEX: 8;
1542
+ readonly BUFFER_CREATIONFLAG_INDEX: 16;
1543
+ readonly BUFFER_CREATIONFLAG_STORAGE: 32;
1544
+ readonly BUFFER_CREATIONFLAG_INDIRECT: 64;
1420
1545
  };
1421
1546
 
1422
1547
  /** Babylon.js `CreateAudioBusAsync`. */
@@ -1634,6 +1759,8 @@ declare interface DashedLinesBuilderOptions {
1634
1759
  material?: unknown;
1635
1760
  }
1636
1761
 
1762
+ export declare type DataArray = number[] | ArrayBufferLike | ArrayBufferView;
1763
+
1637
1764
  declare interface DefaultEnvironmentOptions {
1638
1765
  createSkybox?: boolean;
1639
1766
  createGround?: boolean;
@@ -1749,7 +1876,7 @@ export declare class DynamicTexture extends BaseTexture {
1749
1876
  whenReadyAsync(): Promise<void>;
1750
1877
  }
1751
1878
 
1752
- export declare abstract class EasingFunction {
1879
+ export declare abstract class EasingFunction implements IEasingFunction {
1753
1880
  static readonly EASINGMODE_EASEIN = 0;
1754
1881
  static readonly EASINGMODE_EASEOUT = 1;
1755
1882
  static readonly EASINGMODE_EASEINOUT = 2;
@@ -1762,10 +1889,10 @@ export declare abstract class EasingFunction {
1762
1889
  }
1763
1890
 
1764
1891
  /**
1765
- * Babylon.js-compatible easing functions (pure, no Babylon Lite dependency).
1892
+ * Babylon.js-compatible easing functions over Babylon Lite's functional curves.
1766
1893
  *
1767
- * These mirror Babylon.js's `EasingFunction` hierarchy and easing modes for use
1768
- * with property animations. They are fully unit-testable.
1894
+ * These retain Babylon.js's class hierarchy and easing modes for porting while
1895
+ * delegating curve math to tree-shakable native Lite functions.
1769
1896
  */
1770
1897
  export declare const EASINGMODE_EASEIN = 0;
1771
1898
 
@@ -1782,8 +1909,8 @@ export declare class EffectLayer {
1782
1909
  }
1783
1910
 
1784
1911
  export declare class ElasticEase extends EasingFunction {
1785
- private readonly oscillations;
1786
- private readonly springiness;
1912
+ oscillations: number;
1913
+ springiness: number;
1787
1914
  constructor(oscillations?: number, springiness?: number);
1788
1915
  easeInCore(gradient: number): number;
1789
1916
  }
@@ -1808,7 +1935,7 @@ export declare class ExecuteCodeAction extends Action {
1808
1935
  }
1809
1936
 
1810
1937
  export declare class ExponentialEase extends EasingFunction {
1811
- private readonly exponent;
1938
+ exponent: number;
1812
1939
  constructor(exponent?: number);
1813
1940
  easeInCore(gradient: number): number;
1814
1941
  }
@@ -1943,6 +2070,8 @@ export declare interface FBXLoaderWarning {
1943
2070
 
1944
2071
  export declare type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
1945
2072
 
2073
+ declare type FloatArray = number[] | Float32Array;
2074
+
1946
2075
  export declare enum FlowGraphValidationSeverity {
1947
2076
  Error = 0,
1948
2077
  Warning = 1
@@ -2610,11 +2739,21 @@ export declare interface IAbstractSoundOptions extends Partial<IVolumeAudioOptio
2610
2739
 
2611
2740
  export declare interface IAnimationKey {
2612
2741
  frame: number;
2613
- value: number | number[];
2742
+ value: AnimationValue;
2614
2743
  /** Babylon.js per-key interpolation hint (`AnimationKeyInterpolation`). */
2615
2744
  interpolation?: number;
2616
2745
  }
2617
2746
 
2747
+ /** Structural vector/quaternion value accepted by Babylon.js animation keys. */
2748
+ export declare interface IAnimationVectorValue {
2749
+ readonly x: number;
2750
+ readonly y: number;
2751
+ readonly z?: number;
2752
+ readonly w?: number;
2753
+ clone(): IAnimationVectorValue;
2754
+ asArray(): number[];
2755
+ }
2756
+
2618
2757
  /** Babylon.js `IAudioAnalyzerOptions`. */
2619
2758
  export declare interface IAudioAnalyzerOptions {
2620
2759
  /** Build the analyzer immediately. Defaults to `false`. */
@@ -2668,6 +2807,20 @@ export declare interface ICharacterControllerCollisionEvent {
2668
2807
  impulsePosition: Vector3;
2669
2808
  }
2670
2809
 
2810
+ export declare interface IComputeShaderOptions {
2811
+ bindingsMapping: ComputeBindingMapping;
2812
+ defines?: string[];
2813
+ entryPoint?: string;
2814
+ processFinalCode?: ((code: string) => string) | null;
2815
+ useExplicitComputePipelineLayout?: boolean;
2816
+ }
2817
+
2818
+ export declare interface IComputeShaderPath {
2819
+ computeSource?: string;
2820
+ compute?: string;
2821
+ computeElement?: string;
2822
+ }
2823
+
2671
2824
  /** Babylon.js `ICreateTexture2DArrayFromImageUrlsOptions`. */
2672
2825
  export declare interface ICreateTexture2DArrayFromImageUrlsOptions extends IUploadImageToTexture2DArrayLayerOptions {
2673
2826
  /** Generate a full mip chain (true by default). */
@@ -2695,6 +2848,20 @@ export declare interface IDitheredTileFadeBounds {
2695
2848
  upperBound: number;
2696
2849
  }
2697
2850
 
2851
+ /**
2852
+ * Contract implemented by Babylon.js easing functions.
2853
+ *
2854
+ * Custom easing objects only need to transform a normalized segment gradient.
2855
+ */
2856
+ export declare interface IEasingFunction {
2857
+ /**
2858
+ * Transform a segment-local gradient.
2859
+ * @param gradient - Linear progress through the current keyframe segment.
2860
+ * @returns The progress used for interpolation. Values are not clamped.
2861
+ */
2862
+ ease(gradient: number): number;
2863
+ }
2864
+
2698
2865
  export declare interface IFlowGraphValidationIssue {
2699
2866
  severity: FlowGraphValidationSeverity;
2700
2867
  message: string;
@@ -2870,6 +3037,22 @@ export declare interface IRaycastQuery {
2870
3037
  ignoreBody?: PhysicsBody;
2871
3038
  }
2872
3039
 
3040
+ export declare interface IRootMotionClipOptions {
3041
+ rootNode?: TransformNode | Bone;
3042
+ characterNode?: TransformNode;
3043
+ contactNodes?: Array<TransformNode | Bone>;
3044
+ source?: RootMotionSource;
3045
+ extractRotation?: boolean;
3046
+ samplesPerSecond?: number;
3047
+ minimumTravel?: number;
3048
+ minimumTurn?: number;
3049
+ directionSnapAngle?: number;
3050
+ extractLateralMotion?: boolean;
3051
+ upAxis?: Vector3;
3052
+ name?: string;
3053
+ cloneAnimations?: boolean;
3054
+ }
3055
+
2873
3056
  /**
2874
3057
  * Babylon.js `ISafeOrbitCameraLimits` — safe-orbit camera limits embedded in a Gaussian
2875
3058
  * Splatting file's metadata (Adobe safe-orbit extension). Exposed on the loaded mesh via
@@ -2892,6 +3075,8 @@ export declare interface ISceneLoaderOptions {
2892
3075
  preprocessUrlAsync?: (url: string) => Promise<string>;
2893
3076
  [option: string]: unknown;
2894
3077
  };
3078
+ splat?: Partial<Readonly<SPLATLoadingOptions>>;
3079
+ usd?: Partial<USDFileLoaderOptions>;
2895
3080
  };
2896
3081
  }
2897
3082
 
@@ -3372,6 +3557,11 @@ export declare class Matrix {
3372
3557
  markAsUpdated(): this;
3373
3558
  }
3374
3559
 
3560
+ declare interface MatrixLike {
3561
+ asArray(): ArrayLike<number>;
3562
+ readonly updateFlag?: number;
3563
+ }
3564
+
3375
3565
  export { MaxTintMagnitude }
3376
3566
 
3377
3567
  /** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
@@ -3752,8 +3942,7 @@ export declare class Observable<T> {
3752
3942
  addOnce(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
3753
3943
  remove(callback: ObserverCallback<T> | null | undefined): boolean;
3754
3944
  removeCallback(callback: ObserverCallback<T>): boolean;
3755
- notifyObservers(eventData?: T, mask?: number): void;
3756
- hasObservers(): boolean;
3945
+ notifyObservers(eventData?: T, mask?: number): void;
3757
3946
  hasObservers(): boolean;
3758
3947
  clear(): void;
3759
3948
  cleanLastNotifiedState(): void;
3760
3949
  }
@@ -4557,6 +4746,15 @@ export declare class PostProcess {
4557
4746
  constructor();
4558
4747
  }
4559
4748
 
4749
+ /**
4750
+ * Babylon.js-compatible power easing class.
4751
+ */
4752
+ export declare class PowerEase extends EasingFunction {
4753
+ power: number;
4754
+ constructor(power?: number);
4755
+ easeInCore(gradient: number): number;
4756
+ }
4757
+
4560
4758
  /** Babylon.js `PrecisionDate` — high-resolution timestamp source. */
4561
4759
  export declare const PrecisionDate: {
4562
4760
  readonly Now: number;
@@ -4778,6 +4976,8 @@ export declare function RegisterAbstractEngineTextureLoaders(): void;
4778
4976
  */
4779
4977
  export declare function registerBuiltInLoaders(): void;
4780
4978
 
4979
+ export declare function RegisterComputeShader(): void;
4980
+
4781
4981
  /** Pure-build registration shim; compat wires the Lite array upload directly. */
4782
4982
  export declare function RegisterEnginesExtensionsEngineTexture2DArrayImageSource(): void;
4783
4983
 
@@ -4795,13 +4995,60 @@ export declare function RegisterMeshBlendingPostProcessBlock(): never;
4795
4995
 
4796
4996
  export declare function RegisterOpenpbrMaterial(): void;
4797
4997
 
4798
- export declare function RegisterUSDFileLoader(): never;
4998
+ export declare function RegisterSPLATFileLoader(): void;
4999
+
5000
+ export declare function RegisterUSDFileLoader(): void;
4799
5001
 
4800
5002
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
4801
5003
  export declare class RenderTargetTexture {
4802
5004
  constructor();
4803
5005
  }
4804
5006
 
5007
+ export declare class RootMotionClip {
5008
+ constructor(_animationGroup: AnimationGroup, _options?: IRootMotionClipOptions);
5009
+ get sourceAnimationGroup(): AnimationGroup;
5010
+ get animationGroup(): AnimationGroup;
5011
+ get controller(): RootMotionController | null;
5012
+ get source(): RootMotionSource;
5013
+ get rootNode(): TransformNode | null;
5014
+ get characterNode(): TransformNode;
5015
+ get contactNodes(): ReadonlyArray<TransformNode>;
5016
+ get upAxis(): Vector3;
5017
+ get fromFrame(): number;
5018
+ get toFrame(): number;
5019
+ get travelDirection(): Vector3;
5020
+ get cycleOffset(): Vector3;
5021
+ get cycleDistance(): number;
5022
+ get cycleRotation(): number;
5023
+ get extractsRotation(): boolean;
5024
+ get duration(): number;
5025
+ get averageSpeed(): number;
5026
+ get characterHeight(): number;
5027
+ getOffsetAtFrame(_frame: number, _result: Vector3): Vector3;
5028
+ getRotationAtFrame(_frame: number): number;
5029
+ dispose(): void;
5030
+ }
5031
+
5032
+ export declare class RootMotionController {
5033
+ applyToCharacter: boolean;
5034
+ readonly onRootMotionObservable: Observable<RootMotionController>;
5035
+ constructor(_characterNode: TransformNode, _clips?: RootMotionClip[]);
5036
+ get characterNode(): TransformNode;
5037
+ get clips(): ReadonlyArray<RootMotionClip>;
5038
+ get deltaPosition(): Vector3;
5039
+ get deltaRotation(): number;
5040
+ addClip(_clip: RootMotionClip): void;
5041
+ removeClip(_clip: RootMotionClip): void;
5042
+ reset(): void;
5043
+ dispose(): void;
5044
+ }
5045
+
5046
+ export declare enum RootMotionSource {
5047
+ None = 0,
5048
+ Root = 1,
5049
+ FootContact = 2
5050
+ }
5051
+
4805
5052
  export declare class RotationGizmo extends GizmoBase {
4806
5053
  private _attached;
4807
5054
  private _xGizmo;
4808
5055
  private _yGizmo;
@@ -4874,8 +5121,8 @@ export declare class Scene extends AbstractScene {
4874
5121
  /** Babylon.js fog-mode c
4875
5122
  * Babylon.js `scene.animationGroups` / `scene.animatables`. Loaded glTF /
4876
5123
  * `.babylon` animation clips live on the Lite scene; `animationGroups` returns
4877
5124
  * BJS-shaped `AnimationGroup`s over them (so scenes can `goToFrame`/`pause`/`stop`
4878
- * to freeze a model at a deterministic frame). `animatables` surfaces the running
4879
- * CPU `Animatable`s started via `beginDirectAnimation`.
5125
+ * to freeze a model at a deterministic frame). `animatables` surfaces the
5126
+ * native-backed and fallback `Animatable`s started through the scene.
4880
5127
  */
4881
5128
  get animationGroups(): AnimationGroup[];
4882
5129
  /** Babylon.js `scene.getAnimationGroupByName(name)` — first loaded animation group with a matching name, else `null`. */
@@ -4899,8 +5146,7 @@ export declare class Scene extends AbstractScene {
4899
5146
  /** Babylon.js fog-mode c
4900
5147
  private readonly _pendingMorphBuilds;
4901
5148
  private _materialPluginsRequested;
4902
5149
  private readonly _pendingMaterialPluginReconciliations;
4903
- private readonly _runningAnimatables;
4904
- private readonly _animationGroupCache;
4905
5150
  private _ambientColor;
5151
+ private readonly _runningAnimatables;
4906
5152
  private readonly _animationGroupCache;
4907
5153
  private _ambientColor;
4908
5154
  private _environmentIntensity;
4909
5155
  private _imageProcessingConfiguration;
4910
5156
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
4911
5157
  readonly uniqueId: number;
@@ -5062,8 +5308,9 @@ export declare class Scene extends AbstractScene {
5062
5308
  /** Babylon.js fog-mode c
5063
5309
  disablePhysicsEngine(): void;
5064
5310
  /**
5065
5311
  * Babylon.js `scene.beginDirectAnimation(target, animations, from, to, loop, speedRatio?)`.
5066
- * Drives the given `Animation`s on the CPU each frame, writing onto the target's
5067
- * (dotted) property path. Returns an `Animatable` with `goToFrame`/`pause`/`stop`.
5312
+ * Delegates supported tracks to Babylon Lite property animation and retains
5313
+ * explicit compat evaluation only for unsupported tracks. Returns one facade
5314
+ * coordinating both subsets.
5068
5315
  */
5069
5316
  beginDirectAnimation(target: unknown, animations: Animation_2[], from: number, to: number, loop?: boolean, speedRatio?: number): Animatable_2;
5070
5317
  /**
5071
5318
  * Babylon.js `scene.beginAnimation(target, from, to, loop, speedRatio?)`. Runs
@@ -5355,6 +5602,60 @@ export declare class Spherical {
5355
5602
  static FromArray(array: number[]): Spherical;
5356
5603
  }
5357
5604
 
5605
+ export declare class SPLATFileLoader {
5606
+ readonly name = "splat";
5607
+ readonly extensions: {
5608
+ readonly ".splat": {
5609
+ readonly isBinary: true;
5610
+ };
5611
+ readonly ".ply": {
5612
+ readonly isBinary: true;
5613
+ };
5614
+ readonly ".spz": {
5615
+ readonly isBinary: true;
5616
+ };
5617
+ readonly ".json": {
5618
+ readonly isBinary: false;
5619
+ };
5620
+ readonly ".sog": {
5621
+ readonly isBinary: true;
5622
+ };
5623
+ };
5624
+ private readonly _loadingOptions;
5625
+ constructor(loadingOptions?: Partial<Readonly<SPLATLoadingOptions>>);
5626
+ createPlugin(options: {
5627
+ splat?: Partial<Readonly<SPLATLoadingOptions>>;
5628
+ }): SPLATFileLoader;
5629
+ importMeshAsync(_meshesNames: unknown, scene: Scene, data: unknown, _rootUrl: string, _onProgress?: (event: ISceneLoaderProgressEvent) => void, _fileName?: string): Promise<SPLATImportResult>;
5630
+ loadAsync(scene: Scene, data: unknown, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
5631
+ loadAssetContainerAsync(_scene: Scene, _data: string, _rootUrl: string): Promise<AssetContainer>;
5358
5632
  private _load;
5633
+ private _loadReserved;
5634
+ private _adoptLoaded;
5635
+ }
5636
+
5637
+ declare interface SPLATImportResult {
5638
+ meshes: GaussianSplattingMesh[];
5639
+ particleSystems: unknown[];
5640
+ skeletons: unknown[];
5641
+ animationGroups: unknown[];
5642
+ transformNodes: unknown[];
5643
+ geometries: unknown[];
5644
+ lights: unknown[];
5645
+ spriteManagers: unknown[];
5646
+ }
5647
+
5648
+ export declare type SPLATLoadingOptions = {
5649
+ keepInRam?: boolean;
5650
+ flipY?: boolean;
5651
+ deflateURL?: string;
5652
+ fflate?: unknown;
5653
+ disableAutoCameraLimits?: boolean;
5654
+ gaussianSplattingMesh?: GaussianSplattingMesh;
5655
+ needsRotationScaleTextures?: boolean;
5656
+ useSogTextures?: boolean;
5657
+ spzLibraryUrl?: string;
5658
+ };
5659
+
5359
5660
  export declare class SpotLight extends Light {
5360
5661
  constructor(name: string, position: Vector3, direction: Vector3, angle: number, exponent: number, scene?: Scene);
5361
5662
  getClassName(): string;
5362
5663
  get angle(): number;
@@ -5432,7 +5733,9 @@ export declare class SpriteManager {
5432
5733
  disableDepthWrite: boolean;
5433
5734
  /** Babylon.js `manager.blendMode` (`Constants.ALPHA_*`). Mapped to a Lite billboard blend at build. */
5434
5735
  blendMode: number;
5435
5736
  private _atlas?;
5436
- constructor(name: string, url: string, capacity: number, cellSize: CellSize, scene: Scene, _epsilon?: number, samplingMode?: number);
5737
+ constructor(name: string, url: string, capacity: number, cellSize: CellSize, scene: Scene, _epsilon?: number, samplingMode?: number);
5738
+ /** Babylon.js `SpriteManager.isReady()` — an empty manager is ready without renderer preparation. */
5739
+ isReady(): boolean;
5437
5740
 
5438
5741
  export declare class SpriteMap {
5439
5742
  constructor();
@@ -5478,7 +5781,9 @@ export declare class SpriteRenderer {
5478
5781
  private _built;
5479
5782
  private readonly _indices;
5480
5783
  private _sprites;
5481
- constructor(engine: WebGPUEngine, capacity?: number, _epsilon?: number, _scene?: unknown);
5482
5784
  /**
5785
+ constructor(engine: WebGPUEngine, capacity?: number, _epsilon?: number, _scene?: unknown);
5786
+ /** Babylon.js `SpriteRenderer.isReady()` — the next render can build once its atlas is loaded. */
5787
+ isReady(): boolean;
5483
5788
  /**
5484
5789
  * Babylon.js `renderer.render(sprites, deltaTime, viewMatrix, projectionMatrix)`.
5485
5790
  * The matrices are owned by Babylon Lite's pixel-space sprite pass, so they are
5486
5791
  * accepted for API parity but not consumed. First call builds + registers the
@@ -5610,6 +5915,18 @@ export declare class STLFileLoader {
5610
5915
  constructor();
5611
5916
  }
5612
5917
 
5918
+ /** Babylon.js-shaped wrapper over Lite's public opaque storage allocation. */
5919
+ export declare class StorageBuffer {
5920
+ private readonly _engine;
5613
5921
  private readonly _copyReadable;
5922
+ private readonly _copyWritable;
5923
+ constructor(_engine: WebGPUEngine, size: number, creationFlags?: number, label?: string);
5614
5924
  getBuffer(): StorageBuffer_2 | null;
5925
+ clear(byteOffset?: number, byteLength?: number): void;
5926
+ update(data: DataArray, byteOffset?: number, byteLength?: number): void;
5927
+ read(offset?: number, size?: number, buffer?: ArrayBufferView, noDelay?: boolean): Promise<ArrayBufferView>;
5928
+ dispose(): void;
5615
5929
  private _requireBuffer;
5930
+ private _assertCopyWritable;
5931
+ }
5932
+
5616
5933
  /** Babylon.js `StreamingSound` — a media-element-backed sound. */
5617
5934
  export declare class StreamingSound extends AbstractSound {
5618
5935
  private readonly _autoplay;
5619
5936
  private _loop;
@@ -5857,6 +6174,83 @@ export declare class TransformNode extends Node_2 {
5857
6174
  physicsBody: PhysicsBody
5858
6175
 
5859
6176
  export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
5860
6177
 
6178
+ /** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */
6179
+ export declare class UniformBuffer {
6180
+ private readonly _engine;
6181
+ private readonly _data;
6182
+ private readonly _dynamic;
6183
+ private readonly _uniformLocations;
6184
+ private readonly _uniformSizes;
6185
+ private readonly _uniformArraySizes;
6186
+ private readonly _uniformNames;
6187
+ private _uniformLocationPointer;
6188
+ private _bufferData;
6189
+ private _buffer;
6190
+ private _needSync;
6191
+ private _name;
6192
+ constructor(_engine: AbstractEngine, data?: number[], dynamic?: boolean, name?: string, forceNoUniformBuffer?: boolean, _trackUBOsInFrame?: boolean);
6193
+ readonly updateMatrix3x3: (name: string, matrix: Float32Array) => void;
6194
+ readonly updateMatrix2x2: (name: string, matrix: Float32Array) => void;
6195
+ readonly updateFloat: (name: string, x: number, _suffix?: string) => void;
6196
+ readonly updateFloat2: (name: string, x: number, y: number, _suffix?: string) => void;
6197
+ readonly updateFloat3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
6198
+ readonly updateFloat4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
6199
+ readonly updateFloatArray: (name: string, array: Float32Array, _suffix?: string) => void;
6200
+ readonly updateArray: (name: string, array: number[]) => void;
6201
+ readonly updateIntArray: (name: string, array: Int32Array) => void;
6202
+ readonly updateUIntArray: (name: string, array: Uint32Array) => void;
6203
+ readonly updateMatrix: (name: string, matrix: MatrixLike) => void;
6204
+ readonly updateMatrices: (name: string, matrices: Float32Array) => void;
6205
+ readonly updateVector3: (name: string, vector: Vector3Like) => void;
6206
+ readonly updateVector4: (name: string, vector: Vector4Like) => void;
6207
+ readonly updateColor3: (name: string, color: Color3Like, suffix?: string) => void;
6208
+ readonly updateColor4: (name: string, color: Color3Like, alpha: number, suffix?: string) => void;
6209
+ readonly updateDirectColor4: (name: string, color: Color4Like, suffix?: string) => void;
6210
+ readonly updateInt: (name: string, x: number, _suffix?: string) => void;
6211
+ readonly updateInt2: (name: string, x: number, y: number, _suffix?: string) => void;
6212
+ readonly updateInt3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
6213
+ readonly updateInt4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
6214
+ readonly updateUInt: (name: string, x: number, _suffix?: string) => void;
6215
+ readonly updateUInt2: (name: string, x: number, y: number, _suffix?: string) => void;
6216
+ readonly updateUInt3: (name: string, x: number, y: number, z: number, _suffix?: string) => void;
6217
+ readonly updateUInt4: (name: string, x: number, y: number, z: number, w: number, _suffix?: string) => void;
6218
+ get useUbo(): boolean;
6219
+ get isSync(): boolean;
6220
+ isDynamic(): boolean;
6221
+ getData(): Float32Array;
6222
+ getBuffer(): UniformBuffer_2 | null;
6223
+ getUniformNames(): string[];
6224
+ addUniform(name: string, sizeOrData: number | number[], arraySize?: number): void;
6225
+ addMatrix(name: string, matrix: MatrixLike): void;
6226
+ addFloat2(name: string, x: number, y: number): void;
6227
+ addFloat3(name: string, x: number, y: number, z: number): void;
6228
+ addColor3(name: string, color: Color3Like): void;
6229
+ addColor4(name: string, color: Color3Like, alpha: number): void;
6230
+ addVector3(name: string, vector: Vector3Like): void;
6231
+ addMatrix3x3(name: string): void;
6232
+ addMatrix2x2(name: string): void;
6233
+ create(): void;
5861
6234
  get name(): string;
6235
+ set name(value: string);
6236
+ get currentEffect(): unknown | null;
6237
+ update(): void;
6238
+ updateUniform(uniformName: string, data: FloatArray, size: number): void;
6239
+ updateUniformArray(uniformName: string, data: FloatArray, size: number): void;
6240
+ setTexture(_name: string, _texture: BaseTexture | null): never;
6241
+ setTextureArray(_name: string, _textures: BaseTexture[]): never;
6242
+ bindTexture(_name: string, _texture: unknown | null): never;
6243
+ updateUniformDirectly(uniformName: string, data: FloatArray): void;
6244
+ bindToEffect(_effect: unknown, _name: string): never;
6245
+ bindUniformBuffer(): never;
6246
+ unbindEffect(): void;
6247
+ setDataBuffer(dataBuffer: UniformBuffer_2): boolean;
6248
+ has(name: string): boolean;
6249
+ dispose(): void;
6250
+ private _align;
6251
+ private _updateIntegerUniform;
6252
+ private _updateIntegerUniformArray;
6253
+ private _setInteger;
6254
+ }
6255
+
5862
6256
  /** Babylon.js `UninstallHtmlInCanvasPolyfill` — the HTML-in-canvas polyfill is unsupported by the compat layer. */
5863
6257
  export declare function UninstallHtmlInCanvasPolyfill(): never;
5864
6258
 
@@ -5884,7 +6278,34 @@ export declare function UploadImageToTexture2DArrayLayer(texture: RawTexture2DAr
5884
6278
  export declare type USDBinaryInput = ArrayBuffer | ArrayBufferView;
5885
6279
 
5886
6280
  export declare class USDFileLoader {
5887
- constructor(_options?: Partial<USDFileLoaderOptions>);
6281
+ static get DefaultConfiguration(): Required<Pick<USDFileLoaderOptions, "workerUrl" | "glueUrl" | "wasmUrl" | "dataUrl">>;
6282
+ static set DefaultConfiguration(configuration: Required<Pick<USDFileLoaderOptions, "workerUrl" | "glueUrl" | "wasmUrl" | "dataUrl">>);
6283
+ readonly name = "usd";
6284
+ readonly extensions: {
6285
+ readonly ".usd": {
6286
+ readonly isBinary: true;
6287
+ };
6288
+ readonly ".usda": {
6289
+ readonly isBinary: true;
6290
+ };
6291
+ readonly ".usdc": {
6292
+ readonly isBinary: true;
6293
+ };
6294
+ readonly ".usdz": {
6295
+ readonly isBinary: true;
6296
+ };
6297
+ };
6298
+ private readonly _options;
6299
+ private readonly _activeLoads;
6300
+ constructor(options?: Partial<USDFileLoaderOptions>);
6301
+ createPlugin(options: {
6302
+ usd?: Partial<USDFileLoaderOptions>;
6303
+ }): USDFileLoader;
6304
+ importMeshAsync(_meshNames: string | readonly string[] | null | undefined, scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<USDImportResult>;
6305
+ loadAsync(scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void>;
6306
+ loadAssetContainerAsync(scene: Scene, data: unknown, _rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<AssetContainer>;
6307
+ dispose(): void;
6308
+ private _load;
5888
6309
  }
5889
6310
 
5890
6311
  export declare interface USDFileLoaderOptions {
@@ -5900,38 +6321,24 @@ export declare interface USDFileLoaderOptions {
5900
6321
  onComplete?: (diagnostics: USDImportDiagnostics) => void;
5901
6322
  }
5902
6323
 
5903
- export declare interface USDImportDiagnostics {
5904
- timings: USDImportTimings;
5905
- statistics: USDImportStatistics;
5906
- missingAssets: readonly string[];
5907
- }
6324
+ export declare type USDImportDiagnostics = UsdDiagnostics;
5908
6325
 
5909
- export declare interface USDImportStatistics {
5910
- nodes: number;
5911
- meshes: number;
5912
- analyticPrimitives: number;
5913
- instances: number;
5914
- materials: number;
5915
- vertices: number;
5916
- triangles: number;
5917
- commandBytes: number;
5918
- dataBytes: number;
6326
+ declare interface USDImportResult {
6327
+ meshes: Mesh[];
6328
+ particleSystems: unknown[];
6329
+ skeletons: Skeleton[];
6330
+ animationGroups: AnimationGroup_2[];
6331
+ transformNodes: unknown[];
6332
+ lights: unknown[];
5919
6333
  }
5920
6334
 
5921
- export declare interface USDImportTimings {
5922
- totalMs: number;
5923
- stageOpenMs: number;
5924
- stageReadMs: number;
5925
- preparationMs: number;
5926
- packingMs: number;
5927
- heapCopyMs: number;
5928
- materializeMs: number;
5929
- }
6335
+ export declare type USDImportStatistics = UsdDiagnostics["statistics"];
5930
6336
 
5931
- export declare interface USDLoadProgress {
5932
- phase: "initializing" | "staging" | "extracting" | "materializing";
5933
- message: string;
5934
- }
6337
+ export declare type USDImportTimings = UsdDiagnostics["timings"];
6338
+
6339
+ export declare type USDLoadProgress = Omit<UsdProgress, "phase"> & {
6340
+ phase: Exclude<UsdProgress["phase"], "fetching">;
6341
+ };
5935
6342
 
5936
6343
  export declare type USDVirtualFiles = Readonly<Record<string, USDBinaryInput>>;
5937
6344
 
@@ -6065,6 +6472,12 @@ export declare class Vector3 {
6065
6472
  static TransformNormalToRef<T extends Vector3>(vector: Vector3, transformation: Matrix, result: T): T;
6066
6473
  }
6067
6474
 
6475
+ declare interface Vector3Like {
6476
+ readonly x: number;
6477
+ readonly y: number;
6478
+ readonly z: number;
6479
+ }
6480
+
6068
6481
  export declare class Vector4 {
6069
6482
  x: number;
6070
6483
  y: number;
@@ -6082,6 +6495,10 @@ export declare class Vector4 {
6082
6495
  static Zero(): Vector4;
6083
6496
  }
6084
6497
 
6498
+ declare interface Vector4Like extends Vector3Like {
6499
+ readonly w: number;
6500
+ }
6501
+
6085
6502
  /**
6086
6503
  * Babylon.js `VertexBuffer` — the per-attribute geometry buffer. Only the `kind`
6087
6504
  * string constants are surfaced (used with `mesh.getVerticesData` /